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, a block is a set of zero or more statements surrounded by curly braces `{}`. Blocks are used to define the scope of variables, control structures, methods, and other constructs in Java. Here are some key points about Java blocks:
1.Scope:
- A block defines a scope in Java, and any variable declared within a block is limited to that scope.
- Variables declared inside a block are not visible outside of it.
2. Control Flow Structures:
- Blocks are commonly used with control flow structures such as `if`, `else`, `for`, `while`, and `do-while`.
- These control structures group multiple statements into a single block.
if (condition) {
// statements
} else {
// statements
}
3. Method Bodies:
- Method bodies in Java are also defined using blocks.
- The code inside a method is enclosed within curly braces.
public void myMethod() {
// method body
}
4. Initialization Blocks:
- Initialization blocks are used to initialize instance variables.
- There are two types: instance initialization blocks (run when an instance of the class is created) and static initialization blocks (run when the class is loaded).
{
// instance initialization block
}
static {
// static initialization block
}
5. Anonymous Blocks:
- Java allows the creation of anonymous blocks for static initialization.
- These blocks execute when the class is loaded.
static {
// anonymous block
}
6. Exception Handling:
- Blocks are used extensively in exception handling with `try`, `catch`, and `finally`.
- Code that might throw exceptions is enclosed in a `try` block.
try {
// code that may throw an exception
} catch (Exception e) {
// exception handling
} finally {
// cleanup code (optional)
}
7. Lambda Expressions:
- Blocks are used in lambda expressions to define the body of the lambda.
MyFunctionalInterface myLambda = () -> {
// lambda body
};
8. Local Variables:
- Local variables declared inside a block have block-level scope.
- They are only accessible within that block.
public void myMethod() {
int localVar = 10; // local variable
}
Java blocks provide a structured way to organize and group code, contributing to the readability and maintainability of Java programs.
Comments
Post a Comment