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
 |
The Java compilation process involves several steps, known as the Java compilation and execution lifecycle. Here's an overview:
1. Writing Java Source Code (HelloWorld.java):
// HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Programmers write Java code using a text editor or an integrated development environment (IDE). The code is typically saved in a file with a .java extension. This file contains the human-readable Java source code.
2. Compilation (Java Compiler - javac):
$ javac HelloWorld.java
The Java source code is compiled by the Java Compiler (javac). During compilation, the compiler performs several tasks:
Syntax Checking: Ensures that the code follows the correct syntax defined by the Java language.
Semantic Analysis: Checks for semantic errors, ensuring that the code makes sense in the context of the Java language.
Bytecode Generation: Converts the Java source code into an intermediate form called bytecode. Bytecode is a set of instructions that can be executed by the Java Virtual Machine (JVM).
This compilation process generates one or more bytecode files with a .class extension. In our case, it creates HelloWorld.class.
3. Bytecode (Java Virtual Machine - JVM):
The generated bytecode is platform-independent and can be executed on any system with a compatible Java Virtual Machine (JVM). Bytecode is not machine code; it's an intermediate representation designed for execution on the JVM.
4. Execution (Java Virtual Machine - JVM):
$ java HelloWorld
The java command is used to execute a Java program. It loads the bytecode generated by the compiler and passes it to the JVM. The JVM performs the following tasks:
Class Loading: Loads the compiled classes into the JVM.
Bytecode Verification: Ensures that the bytecode is valid and doesn't violate security constraints.
Just-In-Time (JIT) Compilation: Converts the bytecode into machine code specific to the underlying hardware. This step is performed at runtime for better performance.
Execution: The JVM executes the program, starting with the main method in the specified class (HelloWorld in this case).
The result is the output:
Hello, World!
This entire process is fundamental to Java's "write once, run anywhere" philosophy, allowing Java programs to be executed on any device with a compatible JVM.
Comments
Post a Comment