Socket communication in Java enables communication between two endpoints over a network. There are two main types of sockets: TCP sockets and UDP sockets. Let's explain both types with examples: TCP Socket Communication: 1. **Server Side**: - The server creates a `ServerSocket` object to listen for incoming connections on a specific port. - When a client connects, the server accepts the connection and creates a `Socket` object to communicate with the client. - The server reads from and writes to the socket's input and output streams to communicate with the client. import java.io.*; import java.net.*; public class TCPServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(12345); System.out.println("Server started. Waiting for client..."); Socket clientSocket = serverSocket.accept(); ...
An abstract class in Java is a class that cannot be instantiated directly and is designed to be subclassed. It serves as a blueprint for other classes and may contain one or more abstract methods, which are methods declared without a body. Here are some key points about abstract classes:
1. Cannot be instantiated: An abstract class cannot be instantiated on its own. Instead, it must be subclassed by other classes, which provide concrete implementations for its abstract methods.
2. May contain abstract methods: An abstract class may contain abstract methods, which are declared using the abstract keyword and do not have a body. Subclasses of the abstract class must provide concrete implementations for these abstract methods.
3. Can contain concrete methods: In addition to abstract methods, an abstract class can also contain concrete methods with implementations. These methods are inherited by subclasses but can be overridden if needed.
4. Can contain fields: Abstract classes can have fields, constructors, and other members like a regular class. These members are inherited by subclasses and can be accessed or overridden as needed.
5. Used for code reusability and polymorphism: Abstract classes are useful for defining common behavior and ensuring consistency across related classes. They promote code reusability by providing a common base for subclasses to build upon. They also enable polymorphism, allowing objects of different subclasses to be treated uniformly through their common abstract superclass.
Example:
abstract class Shape {
protected String color;
public Shape(String color) {
this.color = color;
}
// Abstract method
abstract double area();
// Concrete method
public void setColor(String color) {
this.color = color;
}
// Concrete method
public String getColor() {
return color;
}
}
class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color);
this.radius = radius;
}
@Override
double area() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
private double length;
private double width;
public Rectangle(String color, double length, double width) {
super(color);
this.length = length;
this.width = width;
}
@Override
double area() {
return length * width;
}
}
In this example, `Shape` is an abstract class with an abstract method `area()` and concrete methods `setColor()` and `getColor()`. The `Circle` and `Rectangle` classes extend `Shape` and provide concrete implementations for the `area()` method.
Comments
Post a Comment