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 `finally` block in Java is used to define a block of code that will be executed regardless of whether an exception is thrown or not within the `try` block. It provides a way to perform cleanup tasks such as closing resources, releasing locks, or finalizing operations.
Syntax:
try {
// Code that may throw an exception
} catch (ExceptionType ex) {
// Code to handle the exception
} finally {
// Code to be executed regardless of whether an exception occurs or not
}
Explanation:
- The `finally` block is optional and can appear after the `try` block or after the last `catch` block.
- The code inside the `finally` block will always be executed, irrespective of whether an exception occurs in the `try` block or whether it's caught by a `catch` block.
- The `finally` block is often used to release resources that were acquired in the `try` block, ensuring they are properly released even if an exception occurs.
- If an exception occurs in the `try` block and is caught by a `catch` block, the code in the `finally` block will still be executed before control is transferred to the `catch` block.
- If no exception occurs, the `finally` block is executed after the `try` block completes its execution.
Example:
import java.io.FileInputStream;
import java.io.IOException;
public class FinallyBlockExample {
public static void main(String[] args) {
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream("example.txt");
// Code that reads from the file
} catch (IOException e) {
System.out.println("Error reading file: " + e.getMessage());
} finally {
// Close the input stream regardless of whether an exception occurred or not
try {
if (inputStream != null) {
inputStream.close();
}
} catch (IOException e) {
System.out.println("Error closing file: " + e.getMessage());
}
}
}
}
In this example, the `finally` block is used to close the `FileInputStream` resource, ensuring that the file stream is properly closed even if an exception occurs while reading from the file.
Analogy:
Think of the `finally` block as the cleanup crew that arrives after a chaotic event. No matter what happened during the event (the `try` block), whether things went smoothly or there was a disaster, the cleanup crew (the `finally` block) ensures that everything is tidied up and put back in order. They sweep away debris, repair any damage, and restore the environment to its original state.
Comments
Post a Comment