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, variables are containers that store data values. They have a data type and a name. Here are some common types of variables in Java along with examples:
Primitive Data Types:
These are basic data types representing single values.
Examples:
- int age = 25; // Integer variable
- double salary = 55000.50; // Double variable
- char grade = 'A'; // Character variable
- boolean isStudent = true; // Boolean variable
Reference Data Types:
These variables refer to objects. They don't store the actual data but the memory address of the data.
Examples:
- String name = "John"; // String is a reference data type
Arrays:
Arrays are used to store multiple values of the same type in a single variable.
Examples:
- int[] numbers = {10, 20, 30, 40, 50}; // Array of integers
- String[] colors = {"Red", "Green", "Blue"}; // Array of strings
Constants:
Constants are variables whose values cannot be changed once assigned.
Examples:
- final int MAX_VALUE = 100; // Constant variable
Local Variables:
Variables declared inside a method or block of code.
Examples:
void exampleMethod() {
int localVar = 5; // Local variable
}
Instance Variables (Non-static Fields):
Variables declared within a class but outside any method, constructor, or block.
Examples:
public class MyClass {
int instanceVar = 10; // Instance variable
}
Static Variables (Class Variables):
Variables declared with the static keyword, shared by all instances of a class.
Examples:
public class MyClass {
static int staticVar = 20; // Static variable
}
Enum Constants:
Enumerations define a fixed set of constants.
Examples:
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
Implicit Type Conversion:
Java automatically converts smaller data types to larger ones.
Examples:
int intValue = 42;
double doubleValue = intValue; // Implicit casting
Explicit Type Conversion (Casting):
When converting from a larger data type to a smaller one, explicit casting is required.
Examples:
double bigValue = 123.45;
int intValue = (int) bigValue; // Explicit casting
These examples cover a range of variable types and scenarios in Java. Understanding these concepts is crucial for writing effective and readable Java code.
Comments
Post a Comment