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, the `final` keyword is used to restrict the ability to modify entities such as variables, methods, and classes. Here's a breakdown of how `final` is used in different contexts:
1. Final Variables:
- When applied to a variable, it indicates that the variable's value cannot be changed once it has been initialized.
- Final instance variables must be initialized before the constructor completes or through an instance initializer block.
- Final static variables (class variables) must be initialized before the class is loaded, either through direct assignment or within a static initializer block.
public class MyClass {
final int x = 10; // final instance variable
final static int y; // final static variable
static {
y = 20; // initialization of final static variable
}
}
2. Final Methods:
- When applied to a method, it prevents subclasses from overriding that method.
- Final methods are useful when certain behavior of a method should not be changed by subclasses.
Example:
public class Parent {
final void display() {
System.out.println("Parent's display method");
}
}
public class Child extends Parent {
// This will cause a compilation error as final methods cannot be overridden
void display() {
System.out.println("Child's display method");
}
}
3. Final Classes:
- When applied to a class, it indicates that the class cannot be subclassed.
- Final classes are often used for utility classes or classes with immutable behavior.
Example:
final class FinalClass {
// Class definition
}
// This will cause a compilation error as FinalClass cannot be extended
public class SubClass extends FinalClass {
// Class definition
}
4. Final Arguments:
- When applied to method parameters, it ensures that the value of the parameter cannot be changed within the method.
Example:
public void processData(final int value) {
// value = 10; // This will cause a compilation error as value is final
System.out.println("Value: " + value);
}
In summary, the `final` keyword in Java is used to create constants, prevent method overriding, prohibit subclassing, and ensure immutability where needed. It adds clarity, safety, and design constraints to Java programs.
Comments
Post a Comment