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(); ...
The `catch` blocks in Java are used to handle exceptions that occur within a `try` block. Each `catch` block specifies the type of exception it can handle, allowing you to provide different handling logic for different types of exceptions.
Syntax:
try {
// Code that may throw an exception
} catch (ExceptionType1 ex1) {
// Code to handle ExceptionType1
} catch (ExceptionType2 ex2) {
// Code to handle ExceptionType2
} finally {
// Cleanup code (optional)
}
```
Explanation:
- Each `catch` block specifies the type of exception it can handle, denoted by `ExceptionType`. If an exception of that type (or a subtype) occurs in the `try` block, the corresponding `catch` block is executed.
- You can have multiple `catch` blocks to handle different types of exceptions.
- The order of `catch` blocks is important, as Java checks them sequentially from top to bottom. It's recommended to catch subclasses before their superclasses to avoid unreachable code warnings.
- If an exception occurs that is not caught by any of the `catch` blocks in the `try` block, it propagates up the call stack to the calling method or terminates the program if unhandled.
Example:
public class CatchBlockExample {
public static void main(String[] args) {
try {
int result = 10 / 0; // This will throw ArithmeticException
System.out.println("Result: " + result); // This line will not be executed
} catch (ArithmeticException e) {
System.out.println("An arithmetic exception occurred: " + e.getMessage());
} catch (Exception e) {
System.out.println("An exception occurred: " + e.getMessage());
} finally {
System.out.println("Finally block executed.");
}
}
}
In this example, the `try` block attempts to perform division by zero, which throws an `ArithmeticException`. The first `catch` block handles this specific type of exception. If any other type of exception occurs, it is caught by the second `catch` block, which handles exceptions of type `Exception` (the superclass of all exceptions).
Analogy:
Think of `catch` blocks as safety nets deployed along a risky journey. Each safety net is designed to catch specific types of falls or mishaps. If one safety net fails to catch you, another one is there to prevent your descent into chaos. Finally, after navigating the hazards, you reach the `finally` block, where you can assess the situation and continue on your path.
Comments
Post a Comment