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(); ...
Java Modifiers
In Java, modifiers are keywords that provide additional information about classes, methods, and variables. They modify the default behavior of these elements. There are two main categories of modifiers: **access modifiers** and **non-access modifiers.**
Access Modifiers:
1. Private:
- Description: The private modifier restricts access to members (fields and methods) within the same class.
public class MyClass {
private int privateField;
private void privateMethod() {
System.out.println("Private method");
}
}
2. Default (Package-Private):
- Description: Default access means that members are accessible within the same package.
class DefaultAccessClass {
int defaultField;
void defaultMethod() {
System.out.println("Default method");
}
}
3. Protected:
- Description: Protected access allows members to be accessed within the same package and by subclasses.
package mypackage;
public class ProtectedClass {
protected int protectedField;
protected void protectedMethod() {
System.out.println("Protected method");
}
}
4. Public:
- Description: Public access means members can be accessed from any class.
package mypackage;
public class PublicClass {
public int publicField;
public void publicMethod() {
System.out.println("Public method");
}
}
Non-Access Modifiers:
1. Static:
- Description: The static modifier is used to create class-level members. It means the member belongs to the class rather than instances of the class.
public class StaticExample {
static int staticField;
static void staticMethod() {
System.out.println("Static method");
}
}
2. Final:
- Description: The final modifier is used to make members, classes, and methods unchangeable (constant).
public final class FinalClass {
final int finalField = 10;
final void finalMethod() {
System.out.println("Final method");
}
}
3. Abstract:
- Description: The abstract modifier is used with classes and methods. An abstract class cannot be instantiated, and an abstract method must be implemented by any concrete (non-abstract) subclass.
public abstract class AbstractClass {
abstract void abstractMethod();
}
4. Synchronized:
- Description: The synchronized modifier is used to control access to a method or block by multiple threads. It ensures that only one thread can access the method or block at a time.
public class SynchronizedExample {
synchronized void synchronizedMethod() {
System.out.println("Synchronized method");
}
}
5. Volatile:
- Description: The volatile modifier is used with variables to indicate that the variable's value may be changed by multiple threads simultaneously.
public class VolatileExample {
volatile int sharedVariable;
}
6. Transient:
- Description: The transient modifier is used with fields to indicate that they should not be included when the object is serialized.
import java.io.Serializable;
public class TransientExample implements Serializable {
transient int transientField;
}
7. Native:
- Description: The native modifier is used with methods to indicate that they are implemented in platform-dependent code, typically written in languages like C or C++.
public class NativeExample {
native void nativeMethod();
}
Important Points:
- Combining Modifiers:
- Some elements can have multiple modifiers. For example, a method can be both `static` and `final`.
- Use of Modifiers:
- Modifiers help in controlling access, providing encapsulation, and defining the behavior of classes, methods, and variables.
- Best Practices:
- Choose modifiers carefully to achieve the desired level of encapsulation and access control.
Comments
Post a Comment