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(); ...
The "Hello World" program is a simple program that prints the message "Hello, World!" to the console. Let's go through the program and explain each keyword in detail:
public class HelloWorld {
// 'public' is an access modifier. It indicates that the class is accessible from anywhere.
public static void main(String[] args) {
// 'public', 'static', and 'void' are modifiers for the main method.
// 'public' makes the method accessible from anywhere.
// 'static' indicates that the method belongs to the class and not to an instance of the class.
// 'void' means that the method does not return any value.
System.out.println("Hello, World!");
// 'System' is a class in the java.lang package.
// 'out' is a static member of the System class, representing the standard output stream.
// 'println' is a method of the PrintStream class (type of 'out') used to print a line of text.
// ';' is a statement terminator, marking the end of the statement.
}
}
Explanation of each keyword:
1. public` (Access Modifier):
- The `public` keyword is an access modifier. It makes the class or method accessible from anywhere. In this case, the class `HelloWorld` and the `main` method are marked as public.
2. class (Class Declaration):
- The `class` keyword is used to declare a class. In this program, the class is named `HelloWorld`.
3. static (Static Keyword):
- The `static` keyword is used to declare a method or variable that belongs to the class rather than an instance of the class. In the `main` method, it allows the method to be called without creating an instance of the class.
4. void (Return Type):
- The `void` keyword is used as the return type of a method to indicate that the method does not return any value.
5. main` (Main Method):**
- `main` is the name of the method. It is the entry point of a Java program. When the Java program is executed, it starts by calling the `main` method.
6. String[] args (Command-Line Arguments):
- `String[] args` declares a parameter named `args` of type array of strings. It allows the program to accept command-line arguments when it is executed.
7. System.out.println` (Print Statement):
- `System.out.println` is a method that prints the given message to the standard output (console). In this case, it prints "Hello, World!".
8. `;` (Statement Terminator):
- The semicolon `;` is used as a statement terminator in Java, marking the end of a statement.
Now, let's see an example of executing the program and understanding the output:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
When this program is executed, it will output:
Hello, World!
This simple program serves as an introduction to the basic structure of a Java program and the usage of keywords.
Comments
Post a Comment