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(); ...
In Java, an interface reference variable can be used to refer to objects of classes that implement the interface. This allows for polymorphism and flexibility in designing code. Here's how it works:
1. Declaring Interface Reference:
MyInterface obj;
Here, `MyInterface` is the interface, and `obj` is a reference variable of type `MyInterface`.
2. Assigning Objects:
obj = new MyClass(); // MyClass implements MyInterface
The `obj` reference variable can point to any object of a class that implements the `MyInterface` interface.
3. Accessing Methods:
obj.method(); // Calls method() implemented in MyClass
Through the interface reference variable, you can call methods declared in the interface. The actual implementation of the method depends on the class to which `obj` is currently referring.
Example:
// Interface definition
interface MyInterface {
void method();
}
// Class implementing the interface
class MyClass implements MyInterface {
public void method() {
System.out.println("Method implementation in MyClass");
}
}
public class Main {
public static void main(String[] args) {
// Interface reference pointing to MyClass object
MyInterface obj = new MyClass();
obj.method(); // Calls method() implemented in MyClass
}
}
Explanation:
- In this example, `MyClass` implements the `MyInterface` interface.
- We declare an interface reference variable `obj` of type `MyInterface`.
- We instantiate a `MyClass` object and assign it to `obj`.
- Through the `obj` reference variable, we call the `method()` defined in the `MyInterface` interface.
- At runtime, the JVM invokes the `method()` implemented in `MyClass`.
Benefits:
- Interface references provide flexibility in code design by allowing objects of different classes to be treated uniformly.
- They support polymorphism, allowing method calls to be resolved dynamically at runtime based on the actual object type.
- Interfaces facilitate loose coupling and abstraction, enhancing code maintainability and extensibility.
Comments
Post a Comment