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
The `@Override` annotation is used in Java to indicate that a method in a subclass is overriding a method with the same signature in its superclass. It is not mandatory to use `@Override`, but it helps in detecting errors during compilation if the method signature does not match any method in the superclass.
Here are some key points about `@Override`:
1. Purpose: It provides compile-time checking that a method is indeed overriding a method from a superclass. If there is a mismatch in the method signature (e.g., misspelling of method name, incorrect parameters), the compiler will generate an error.
2. Usage: `@Override` is placed immediately before the method declaration in the subclass that is intended to override a method in the superclass.
3. Compatibility: `@Override` annotation was introduced in Java 5. It can only be used with methods that are overriding a superclass method. If a method is not overriding a superclass method, using `@Override` will result in a compilation error.
4. Benefits: Helps in code maintenance and readability by clearly indicating that a method is intended to override a method from the superclass. It also ensures that the method signature is correct.
Here's an example demonstrating the usage of `@Override`:
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void makeSound() { // Overriding the makeSound method from the superclass
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog(); // Creating an instance of Dog but referenced as Animal
animal.makeSound(); // Calls the makeSound method of Dog class
}
}
In this example, the `makeSound()` method in the `Dog` class overrides the `makeSound()` method in the `Animal` class. The `@Override` annotation is used to explicitly indicate that the method is intended to override a method from the superclass. If there is a mistake in the method signature, such as misspelling `makeSound` as `makeSounds`, the compiler will generate an error, helping to catch errors early in the development process.
Comments
Post a Comment