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 Access Control
Overview:
In Java, access control determines the visibility and accessibility of classes, methods, and fields within the same class, package, or different packages. There are four access control modifiers in Java:
- private:
- Access is limited to the class itself.
- Fields, methods, and inner classes can be private.
- default:
- Access is limited to the package (no modifier is needed).
- Fields, methods, and classes without any specified modifier have default access.
- protected:
- Access is limited to the package and subclasses.
- Fields, methods, and classes can be protected.
- public:
- Access is not restricted.
- Fields, methods, and classes can be accessed from any class.
Examples:
Private Access Modifier:
public class MyClass {
private int privateField;
private void privateMethod() {
System.out.println("Private method");
}
}
Default Access Modifier:
class DefaultAccessClass {
// Default access fields and methods
int defaultField;
void defaultMethod() {
System.out.println("Default method");
}
}
Protected Access Modifier:
package mypackage;
public class ProtectedClass {
protected int protectedField;
protected void protectedMethod() {
System.out.println("Protected method");
}
}
Public Access Modifier:
package mypackage;
public class PublicClass {
public int publicField;
public void publicMethod() {
System.out.println("Public method");
}
}
Important Points:
- Access Hierarchy:
- Access levels follow a hierarchy: `private` < `default` < `protected` < `public`.
- Package Visibility:
- Classes, methods, and fields with the default (package-private) modifier are accessible within the same package.
- Inheritance and Protected:
- The `protected` modifier allows access within subclasses, even if they are in different packages.
- Encapsulation:
- Encapsulation is achieved through access modifiers. It helps in hiding the implementation details and exposing only what is necessary.
- Access Control Best Practices:
- Limit access as much as possible (use the most restrictive access level that makes sense).
- Encapsulate fields by making them private and providing public getter and setter methods when necessary.
Remember: Proper use of access modifiers enhances code readability, maintainability, and security by controlling the exposure of implementation details.
Comments
Post a Comment