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(); ...
Type casting in Java is the process of converting a variable from one data type to another. It's essential when you want to assign a value of one data type to a variable of another data type or perform operations that involve different data types. Here are the key points about type casting in Java:
1. Implicit Casting (Widening):
- Definition: Automatic conversion of a lower data type to a higher data type.
- Example:
int intValue = 10;
double doubleValue = intValue; // Implicit casting from int to double
2. Explicit Casting (Narrowing):
- Definition: Manual conversion of a higher data type to a lower data type.
- Example:
double doubleValue = 10.5;
int intValue = (int) doubleValue; // Explicit casting from double to int
- Caution: Explicit casting may result in loss of data if the value is too large to fit in the target data type.
3. Casting Between Primitive Data Types:
- Example:
int intValue = 100;
char charValue = (char) intValue; // Casting from int to char
4. Casting with Floating-Point Numbers:
-Example:
double doubleValue = 10.75;
int intValue = (int) doubleValue; // Casting from double to int
- Caution: The decimal part is truncated when casting a floating-point number to an integer.
5. Casting with Objects (Reference Types):
- Example:
Object obj = "Hello";
String str = (String) obj; // Casting from Object to String
- Caution: Ensure that the object is of the correct type; otherwise, a `ClassCastException` may occur.
6. instanceof Operator:
- Example:
Object obj = "Hello";
if (obj instanceof String) {
String str = (String) obj;
System.out.println(str);
}
- Caution: Use `instanceof` to check the type before casting to avoid runtime errors.
Type casting is a crucial aspect of Java programming, enabling flexibility when working with different data types. While implicit casting is automatic, explicit casting requires manual intervention and careful consideration to avoid data loss or runtime errors. Understanding how to use casting effectively contributes to writing robust and efficient Java code.
Comments
Post a Comment