Main Method in Java

facts about public static void main in java

The `public static void main(String[] args)` method in Java is a special method that serves as the
entry point for any standalone Java application. Here are some key facts about it:

1. Public Access Modifier:

`public`: The method must be public so that it can be accessed by the Java Virtual Machine
(JVM) to start the application.
2. Static Keyword:
`static`: The method is static so that it can be called without creating an instance of the class.
This is necessary because no objects exist when the JVM starts executing the program.
3. Return Type:
`void`:The method does not return any value. It is designed to be the starting point of the
application and typically doesn't need to return any value to the JVM.
4. Parameter:
`String[] args`: The method accepts a single argument: an array of `String` objects. This
array holds the command-line arguments passed to the program when it is run. The name of
the parameter (`args`) is conventional but can be changed.
5. Execution by JVM:
The JVM looks for the `main` method when starting a Java application. It specifically looks for
the method signature `public static void main(String[] args)`.
6. Application Entry Point:
The `main` method is the starting point from which the JVM starts the execution of the
program. Any other methods or objects used in the application are called or instantiated from
within this method (or methods it calls).
7. Not Restricted to One:
A Java class can have multiple `main` methods with different parameter lists (method
overloading), but only the method with the `String[] args` parameter is recognized as the
entry point by the JVM.
8. Usage in Testing and Utilities:
Developers often use `main` methods for testing purposes or for utility classes to provide a
quick way to run and test the functionality of a class.

Here’s a simple example of a `main` method in a Java class:

java

public class HelloWorld {

public static void main(String[] args) {

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/10
 System.out.println("Hello, World!");
}
}

In this example, when the class is executed, the JVM calls the `main` method, which prints "Hello, World!"
to the console.

when was this main method introduced in java ?

The `public static void main(String[] args)` method was introduced with the very first version of Java,
known as Java 1.0, which was released by Sun Microsystems in January 1996. This method has been a
fundamental part of Java programming from the beginning, providing the entry point for standalone
Java applications.

is there any way to start the java program without main method () ?

In standard Java applications, the `public static void main(String[] args)` method is the conventional
and required entry point for program execution. However, there are some scenarios where Java
programs can be started without directly using the `main` method, though these are not typical for
standard applications:

1. Using Static Initializers:

A class can use static initializers (static blocks) to execute code when the class is loaded.
However, this approach still requires a class with a `main` method to trigger the class loading.

java

public class StaticInitializerExample {

static {
System.out.println("This runs before the main method.");
System.exit(0);
}

public static void main(String[] args) {

// This code will not be reached.
}
}

2. Using Applets:
Applets are a type of Java program that can run in a web browser. They don't require a `main`
method but instead use lifecycle methods like `init()`, `start()`, `stop()`, and `destroy()`.
Note that applets are largely obsolete and no longer supported in many modern browsers.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 2/10
 java

import java.applet.Applet;
import java.awt.Graphics;

public class MyApplet extends Applet {

public void paint(Graphics g) {
g.drawString("Hello, World!", 20, 20);
}
}

3. Using Servlets:
Java Servlets run on a server and handle web requests. They don't use a `main` method but
instead use lifecycle methods such as `init()`, `service()`, and `destroy()`.

java

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().print("Hello, World!");
}
}

4. Java EE Applications:
Enterprise applications running on Java EE (Jakarta EE) servers use managed environments
where components like EJBs (Enterprise JavaBeans) or JPA (Java Persistence API) entities don't
require a `main` method.
5. JavaFX Applications:
JavaFX applications can use the `Application` class, which provides a `start(Stage
primaryStage)` method instead of a `main` method. However, a `main` method might still be
used as a workaround to launch the application on some platforms.

java

import javafx.application.Application;
import javafx.stage.Stage;

public class MyJavaFXApp extends Application {

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello, World!");
primaryStage.show();
}

public static void main(String[] args) {

launch(args);
}
}

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 3/10
While these alternatives exist, the `main` method remains the primary entry point for standard Java
applications and is required for running standalone programs directly from the command line or an IDE.

Using Static Initializers supported until which version of java ?

Using static initializers has been supported in Java from the very beginning, starting with Java 1.0, and
continues to be supported in the latest versions of Java, including Java 17 and beyond. Static initializers
are a fundamental part of the Java language specification and are unlikely to be removed in future
versions as they provide a useful way to initialize static variables and execute code when a class is
loaded.

Here’s an example demonstrating the use of a static initializer block:

java

public class StaticInitializerExample {

static {
System.out.println("This runs before the main method.");
System.exit(0); // Exits the program
}

public static void main(String[] args) {

// This code will not be reached.
}
}

In this example, the static initializer block will execute when the class is loaded, and the message "This
runs before the main method." will be printed. The program then exits before reaching the `main`
method.

Static initializers are a standard feature of the Java language and are useful for various purposes, such
as setting up static fields or performing one-time initialization tasks. They have been consistently
supported across all Java versions, from the earliest to the latest.

can i run the java program without main method () ?

In a traditional standalone Java application, the `public static void main(String[] args)` method is the
required entry point for the Java Virtual Machine (JVM) to start the application. However, there are
several ways to run Java code without a main method in specific contexts or environments. Here are a
few:

1. Using Static Initializers:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 4/10
 While static initializers can run code, they still need a class to be loaded, which typically
happens when a `main` method or other entry point triggers the class loading.

java

public class StaticInitializerExample {

static {
System.out.println("This runs before the main method.");
System.exit(0);
}

public static void main(String[] args) {

// This code will not be reached.
}
}

2. Applets:
Java Applets don't require a `main` method. Instead, they use lifecycle methods like `init()`,
`start()`, `stop()`, and `destroy()`. Note that applets are now largely obsolete and
unsupported in modern browsers.

java

import java.applet.Applet;
import java.awt.Graphics;

public class MyApplet extends Applet {

public void paint(Graphics g) {
g.drawString("Hello, World!", 20, 20);
}
}

3. Java EE (Jakarta EE) Components:

Enterprise applications running on Java EE servers, such as Servlets, EJBs, and other managed
components, don't require a `main` method. They use the server's lifecycle methods and
annotations.

java

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class MyServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().print("Hello, World!");
}
}

4. JavaFX Applications:
JavaFX applications can use the `Application` class, which has a `start(Stage primaryStage)`
method. While a `main` method might still be present for launching, it's not always required.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 5/10
 java

import javafx.application.Application;
import javafx.stage.Stage;

public class MyJavaFXApp extends Application {

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello, World!");
primaryStage.show();
}

public static void main(String[] args) {

launch(args);
}
}

5. JUnit Tests:
JUnit tests don't require a `main` method. They use annotations like `@Test` to designate test
methods that the JUnit framework will execute.

java

import org.junit.Test;
import static org.junit.Assert.*;

public class MyTest {

@Test
public void testSomething() {
assertEquals(2, 1 + 1);
}
}

6. JavaScript Nashorn Engine (Java 8 and later):

Java 8 introduced the Nashorn JavaScript engine, allowing Java code to be embedded and
executed without a `main` method, using JavaScript.

javascript

print('Hello, World!');

To run this script, you would use the `jjs` tool provided with Java 8:

go

```sh
jjs script.js
```

While these methods allow Java code to run without a `main` method, they are typically used in specific
contexts or environments that manage the lifecycle of the application differently from a standard
standalone Java application.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 6/10
 Java is the familiar and amazing programming language with powerful features. whenever we heard
the word java then suddenly one basic thing hits our mind that is public static void main() method.
From the begineer to expert, all the people known about this Java structure.
checks the grammer and correct it

Java is a familiar and amazing programming language with powerful features. Whenever we hear the
word Java, one basic thing that suddenly comes to mind is the `public static void main(String[] args)`
method. From beginners to experts, everyone knows about this fundamental Java structure.

This main() method is the entry point of the every Java program. It introduced in the early version of
java 1.0 . Interestingly, in JDK 1.6 and earlier, we can print something in the output without using
main method. That's possible by static block, which is also known as a static initializer or static
clause. It is a special block of code within a class. It executes only once: specifically, the first time the
class is loaded into memory by the Java Virtual Machine (JVM).There's no need to explicitly call them;
they run as part of the class initialization process. However, this behavior changed in later versions
of Java.

checks the grammer and correct it

This `main()` method is the entry point of every Java program. It was introduced in the early version of
Java 1.0. Interestingly, in JDK 1.6 and earlier, we could print something to the output without using the
`main` method. This was possible through a static block, also known as a static initializer or static clause.
It is a special block of code within a class that executes only once: specifically, the first time the class is
loaded into memory by the Java Virtual Machine (JVM). There's no need to explicitly call it; it runs as part
of the class initialization process. However, this behavior changed in later versions of Java.

There are different JDK are introduced. Even, JDK 22 also introduced recently in march 2024, still why
we need to know about 21 ?
The thing is Java 21 introduced as stable LTS version, which had lots of new features introduced. As
specified by JSR 396 in the Java Community Process, these features aim to enhance productivity,
flexibility, and efficiency in Java development. Among those features, one of the notable feature is
"no longer required of public static void main(string args[]) method".

checks the grammer and correct it

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 7/10
There are different JDKs introduced. Even JDK 22 was introduced recently in March 2024. Still, why do we
need to know about JDK 21? The reason is that Java 21 was introduced as a stable LTS (Long-Term
Support) version, which includes many new features. As specified by JSR 396 in the Java Community
Process, these features aim to enhance productivity, flexibility, and efficiency in Java development.
Among those features, one notable change is that the `public static void main(String[] args)` method
is no longer required.

Lets dive into our Java 21 interesting features,

checks the grammer and correct it

Let's dive into the interesting features of Java 21:

In older java - earlier Java 21.

checks the grammer and correct it

In older Java versions—earlier than Java 21:

For easily understanding the feature , I try explain in simpler way. In Java 21, Public and static
keyword in main method is not required for creating the entry point in java. Instead, simply create
the main method with void keyword is enough to kick start the program in Java 21.
checks the grammer and correct it

For easier understanding of the feature, let me explain it in a simpler way: In Java 21, the `public` and
`static` keywords are no longer required in the `main` method to create the entry point in Java. Instead,
simply creating the `main` method with the `void` keyword is enough to kickstart the program in Java
21.

For executing this above code, first ensure the JDK 21 is installed in your system then make sure the
path variable is perfectly mapped. Then check the version of java using
checks the grammer and correct it

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 8/10
To execute the above code, first ensure JDK 21 is installed on your system. Then, make sure the PATH
variable is correctly set. Next, check the Java version using:

finally, execute the program by using

checks the grammer and correct it

Finally, execute the program by using

Its seems interesting right !..

Another one interesting feature is Unnamed classes.
In Java 21, this feature allows developer to create and run a simple java program without writing a
single java class.
checks the grammer and correct it

It seems interesting, right?

Another interesting feature is Unnamed classes. In Java 21, this feature allows developers to create and
run a simple Java program without writing a single Java class.

See, this above code seems like C program code, right. Its make more easier and better
understanding for begineer.
I hope this will helps to understand the feature in java 21. There are some other amazing features
are also there in java 21. I complete with my favourite quotes
The only constant in the technology industry is change! - Marc Benioff's

checks the grammer and correct it

See, the code above resembles a C program, right? It makes it much easier and better for beginners to
understand.
I hope this helps in understanding the features in Java 21. There are some other amazing features in
Java 21 as well. I'll conclude with one of my favorite quotes:
"The only constant in the technology industry is change!" - Marc Benioff

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 9/10
 Interesting thing about Java 21 — public static void main() method no longer required

checks the grammer and correct it

Interesting thing about Java 21: the `public static void main()` method is no longer required.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 10/10