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(); ...
Object streams in Java are used to serialize and deserialize objects, allowing them to be written to and read from streams. Here are some notes and examples on object streams:
1. Object Streams:
- Object streams allow for the serialization and deserialization of Java objects.
- They provide a convenient way to persist Java objects to files or transmit them over networks.
2. ObjectInputStream and ObjectOutputStream:
- `ObjectInputStream` and `ObjectOutputStream` are classes in Java used for reading and writing objects to streams.
- These classes wrap byte streams and provide methods like `readObject()` and `writeObject()`.
Example (Writing Objects to ObjectOutputStream):
import java.io.*;
public class ObjectOutputStreamExample {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objects.ser"));
Person person = new Person("John", 30);
oos.writeObject(person);
oos.close();
}
}
Example (Reading Objects from ObjectInputStream):
import java.io.*;
public class ObjectInputStreamExample {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("objects.ser"));
Person person = (Person) ois.readObject();
ois.close();
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
Explanation:
- In the first example, we create a `Person` object and write it to an `ObjectOutputStream`.
- In the second example, we read the `Person` object back from the `ObjectInputStream` and print its attributes.
3. Serializable Interface:
- For an object to be serialized, its class must implement the `Serializable` interface.
- This interface is a marker interface that indicates the object is serializable.
Example (Serializable Class):
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getters and setters
// ...
}
Explanation:
- The `Person` class implements the `Serializable` interface, allowing its objects to be serialized.
These examples demonstrate how to use `ObjectInputStream` and `ObjectOutputStream` to serialize and deserialize objects in Java. They provide a powerful mechanism for handling complex data structures and persisting application state.
Comments
Post a Comment