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(); System.out.println("Client connected."); BufferedReader in = new Bu
In Java, constructors are not directly inherited by subclasses like other methods and fields. However, there is a concept called constructor chaining or implicit constructor invocation, which allows subclasses to implicitly call a constructor of the superclass before executing their own constructor code.
Here's how constructor inheritance works in Java:
1. Implicit Constructor Invocation:
- When you create an instance of a subclass, Java automatically invokes a constructor of the superclass before executing the constructor code of the subclass.
- If the subclass constructor does not explicitly call a superclass constructor using `super(...)`, Java will automatically call the no-argument constructor of the superclass.
2. Explicit Constructor Invocation:
- If the superclass does not have a no-argument constructor, or if the subclass constructor wants to call a specific superclass constructor with arguments, you must explicitly invoke the superclass constructor using `super(...)`.
- This explicit invocation of the superclass constructor must be the first statement in the subclass constructor.
Here's an example to illustrate constructor inheritance in Java:
class Vehicle {
String make;
// Superclass constructor
Vehicle(String make) {
this.make = make;
System.out.println("Vehicle constructor invoked");
}
}
class Car extends Vehicle {
String model;
// Subclass constructor
Car(String make, String model) {
super(make); // Invoking superclass constructor explicitly
this.model = model;
System.out.println("Car constructor invoked");
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car("Toyota", "Camry");
System.out.println("Make: " + myCar.make);
System.out.println("Model: " + myCar.model);
}
}
In this example:
- The `Car` class extends the `Vehicle` class.
- The `Vehicle` class has a constructor that takes a `make` parameter.
- The `Car` class constructor explicitly invokes the `Vehicle` constructor using `super(make)` to initialize the `make` field inherited from the superclass.
- When you create an instance of `Car`, both the `Vehicle` constructor and the `Car` constructor are invoked, ensuring that the `make` field is initialized properly.
So, while constructors are not directly inherited in Java, constructor chaining ensures that constructors of the superclass are invoked before executing the subclass constructors, thereby facilitating constructor inheritance.
Comments
Post a Comment