how to make main method in java

We Love Servers.

• WHY IOFLOOD?
• BARE METAL CLOUD
• DEDICATED SERVERS

The Java main() Method: Basics to Advanced Usage

Are you finding it challenging to understand the Java main method? You’re not alone. Many developers, especially beginners, find it a bit daunting. Think of the Java main method as the ‘ignition key’ of your Java program – it’s the entry point that gets your code running.

The Java main method is crucial in any Java application. It’s where the Java Virtual Machine (JVM) starts executing your program. Understanding how it works and how to use it effectively is a vital skill for any Java developer.

In this guide, we’ll walk you through the ins and outs of the Java main method, from basic usage to advanced techniques. We’ll cover everything from the syntax and components of the main method, how to use command-line arguments, alternative ways to structure a Java program, to troubleshooting common issues.

So, let’s dive in and start mastering the Java main method!

TL;DR: What is the Java main method?

The Java main method is the entry point of any Java application. The most common method to call main is public static void main(String[] args) It’s the starting point where the Java Virtual Machine (JVM) begins executing your program. Here’s a simple example:

In this example, we’ve defined a main method that prints ‘Hello, World!’ to the console. The public static void main(String[] args) line is the standard declaration for the main method in Java. The JVM looks for this method signature to start the program.

This is a basic way to use the Java main method, but there’s much more to learn about it. Continue reading for a more detailed explanation and advanced usage scenarios.

Table of Contents

The Basics of Java Main Method

Leveraging command-line arguments in java main method, exploring alternative approaches to java main method, troubleshooting common java main method errors, understanding the jvm and java main method, the role of java main method in larger applications, wrapping up: mastering the java main method.

The Java main method is the entry point of any Java application. When you run a Java program, the Java Virtual Machine (JVM) looks for the main method to start the program. The main method must have a specific signature to be recognized by the JVM.

Here’s the syntax of the main method:

Let’s break down the components of this syntax:

• public : This is an access modifier that means the main method is accessible everywhere.
• static : This keyword means the main method belongs to the class, not an instance of the class. Thus, the JVM can call it without creating an instance of the class.
• void : This keyword indicates that the main method doesn’t return anything.
• main : This is the name of the method. The JVM looks for this method to start the program.
• String[] args : This is an array of Strings passed as command-line arguments.

Here’s a simple example of a Java program with a main method:

In this example, the main method prints ‘Hello, World!’ to the console. When you run this program, the JVM calls the main method, and ‘Hello, World!’ gets printed on your console.

The main method is crucial in any Java program. Without it, the JVM wouldn’t know where to start executing your program. It’s like the ‘ignition key’ of your Java program.

The Java main method isn’t just the starting point of your Java program. It also provides a way to accept input from the user through command-line arguments. These are values that you can pass to your program at the time of execution.

The command-line arguments are represented as an array of Strings ( String[] args ) in the main method signature. The args array is created and populated by the Java runtime system when your program starts. Each value in the args array is a separate command-line argument.

Here’s a simple example to demonstrate how command-line arguments work:

In this example, the main method iterates over the args array and prints each command-line argument to the console. When you run this program with ‘Hello’ and ‘World’ as command-line arguments, it prints ‘Hello’ and ‘World’ on separate lines.

Command-line arguments are a powerful feature of the Java main method. They allow you to customize the behavior of your program at runtime without changing the code.

While the standard public static void main(String[] args) method is the most common entry point for Java applications, there are alternative ways to structure your Java program. Let’s explore some of these approaches.

Non-Static Main Method

It’s possible to have a non-static main method in your Java class, but you should be aware that the JVM won’t recognize this as the entry point of your application. Here’s an example:

In this example, we’ve defined a main method that’s not static. When you try to run this program, the JVM can’t find the main method because it’s looking for a static main method.

Multiple Main Methods

A Java program can have multiple main methods across different classes. This can be useful in large applications where different entry points are needed. Here’s an example:

In this example, we have two classes, each with its own main method. You can run each class separately, and the JVM will start the program from the main method of the class you run.

These alternative approaches offer flexibility in structuring your Java program. However, they come with their own set of considerations. For instance, a non-static main method won’t be recognized by the JVM as the entry point of your application, and having multiple main methods can make your program more complex to understand and maintain.

Even with the best understanding of the Java main method, you might encounter some common errors. Let’s discuss these errors and how to solve them.

‘Main Method Not Found’ Error

This error typically occurs when the JVM can’t find a main method with the correct signature. Here’s an example of a program that will produce this error:

In this example, the main method is not static, so the JVM can’t find it. To solve this error, you need to make the main method static:

In the fixed program, the main method is static, so the JVM can find it and start the program.

Best Practices for the Java Main Method

Here are some best practices for using the Java main method:

• Always make the main method static. This allows the JVM to call it without creating an instance of the class.
• Keep the main method clean and concise. It should only contain the logic needed to start your program. Any additional logic should be placed in separate methods or classes.
• If your program needs to accept user input, consider using command-line arguments. They provide a flexible way to pass values to your program at runtime.

By following these best practices and understanding how to troubleshoot common errors, you can use the Java main method more effectively in your programs.

To fully understand the Java main method, it’s crucial to have a deeper understanding of the Java Virtual Machine (JVM) and the concepts of ‘static’, ‘void’, and ‘public’.

The Role of JVM in Java Main Method

The JVM is an abstract computing machine that enables a computer to run a Java program. When you run a Java program, the JVM is responsible for loading the class files and starting the execution from the main method.

In this example, when you run the HelloWorld class, the JVM loads the HelloWorld class into memory, finds the main method, and starts executing the program from there.

The ‘static’, ‘void’, and ‘public’ Keywords

The main method in Java is typically declared as public static void main(String[] args) . Each of these keywords plays a crucial role:

• public : This keyword means the main method is accessible everywhere, including from outside the class. This is necessary because the main method is called by the JVM, which is outside the scope of the class.
• static : This keyword allows the JVM to call the main method without creating an instance of the class. If the main method wasn’t static, the JVM would need to instantiate the class before calling the main method, which isn’t desirable because the main method needs to start executing as soon as the class is loaded.
• void : This keyword indicates that the main method doesn’t return a value. This is because the main method is the starting point of the program, not a method to perform a calculation and return a result.

Understanding these fundamentals is key to mastering the Java main method. It helps you understand not just how to use the main method, but also why it’s designed the way it is.

The Java main method is not just the starting point of small Java programs; it also plays a crucial role in larger Java applications. In a large application, the main method can be used to initialize the application, load configuration settings, start threads, or perform any other setup tasks required by the application.

Exploring Related Topics

Understanding the Java main method is a great start, but there’s much more to learn in Java. Here are some related topics that you might find interesting:

• Java Object-Oriented Programming (OOP) Concepts : Java is an object-oriented programming language. Learning about OOP concepts like classes, objects, inheritance, polymorphism, and encapsulation can help you write more efficient and maintainable Java programs.

Java Threads : Threads are a fundamental part of concurrent programming in Java. Understanding how to create and manage threads can help you write programs that perform multiple tasks simultaneously.

Further Resources for Mastering Java

Ready to dive deeper into Java? Here are some resources that you might find helpful:

• Java Methods Tutorial: Best Practices and Tips – Discover comprehensive guidance on Java methods for all levels.

Simple Method Invocation in Java explore different techniques to invoke methods in Java.

Main Method Syntax in Java – Master the main method in Java for starting Java programs.

Oracle’s official Java Tutorials cover basic to advanced topics of Java programming.

Java Code Geeks offers tutorials and articles on the Java main method, threads, and more.

Baeldung’s Guide to Java covers the Java core language, Spring framework, and more.

In this comprehensive guide, we’ve delved into the Java main method, a critical component in any Java application. We’ve explored its role as the entry point of Java programs and how it interacts with the Java Virtual Machine (JVM).

We began with the basics, understanding the syntax and components of the main method and how to use it in a simple Java program. We then delved into more advanced usage, learning how to leverage command-line arguments to pass values to the program at runtime.

We also explored alternative approaches to the Java main method, such as using non-static methods or having multiple main methods across different classes. We discussed the benefits and drawbacks of these approaches, helping you understand when to use them.

We tackled common issues you might encounter, such as the ‘Main method not found’ error, and provided solutions to help you troubleshoot these challenges. We also provided best practices for using the Java main method effectively in your programs.

Here’s a quick comparison of the methods we’ve discussed:

Whether you’re just starting out with Java or you’re looking to deepen your understanding of the language, we hope this guide has given you a more profound understanding of the Java main method and its role in Java applications.

With this knowledge, you’re now equipped to write more efficient and effective Java programs. Happy coding!

About Author

Gabriel Ramuglia

Gabriel is the owner and founder of IOFLOOD.com , an unmanaged dedicated server hosting company operating since 2010.Gabriel loves all things servers, bandwidth, and computer programming and enjoys sharing his experience on these topics with readers of the IOFLOOD blog.

Related Posts

Java main method Explained [Easy Examples]

January 7, 2024

Introduction to Java Main Method

In the realm of Java, the main method is the entry point of any standard Java application. Think of it as the grand gateway to the world of your Java program. Whether you've written a complex software or a simple "Hello, World!" program, the Java Virtual Machine (JVM) looks for this method to kickstart the execution of your application.

While most programming languages have some concept of a starting point, the main method in Java holds significance not just as a start but as a convention. Without it, your standalone Java application simply cannot begin its execution. This convention is so entrenched that even the most advanced Integrated Development Environments (IDEs) automatically scaffold it when you create a new Java project.

Syntax of the Java Main Method

The signature of the main method is unmistakable and unique:

Let's briefly deconstruct it:

• public : This access modifier allows the main method to be accessible everywhere, ensuring the JVM can call it without any access restrictions.
• static : Being a static method means you don't need an instance of the class to call the main method. This is vital, as your application hasn't begun and no objects have been created when the JVM starts the execution.
• void : The main method doesn't return anything. It's the start, not a process that gives back a result.
• main : It's the name of the method that the JVM looks for.
• String[] args : This parameter allows the method to accept an array of string values – these are command-line arguments that can be passed when starting your application.

Why public static void main(String[] args) ?

When you start learning Java, one of the first lines of code you encounter is public static void main(String[] args) . This is the entry point for every Java application—a gateway through which the Java Virtual Machine (JVM) starts running your code. But why exactly is this the convention? Let's dissect each part of this signature:

Role of public :

The public is a Java keyword that declares a member's access as public. Public members are visible to all other classes. This means that any other class can access a public field or method. Further, other classes can modify public fields unless the field is declared as final. The main method in java is public so that it can be accessible everywhere and to every object which may desire to use it for launching the application.

Notice that if we will not make the Java main method public, then there will be no compilation error. But we will get runtime error because matching the main method is not present. Remember that the whole syntax should match to execute the java main method. For example, see the example below:

Notice that it says the main.java is not executable, that is because our main method is not public.

Role of static :

In the Java programming language, the keyword static indicates that the particular member belongs to a type itself, rather than to an instance of that type. This means that only one instance of that static member is created which is shared across all instances of the class. In simple words, static methods are the method that invokes without creating the objects, so we do not need any object to call the main method. If we will not make the main method static we will get the following error. See the example below:

Notice that it says the Java main method is not found and gave us the proper syntax of the main method.

Role of void :

The void keyword specifies that a method should not have a return value . In java, every method should have a return type otherwise we will get an error. The main method's type is void which means that it is not returning anything. If we create the main method without any return type (void) we will get the following error.

Purpose of String[] args :

The java main method can also accept some data from the user. It accepts a group of strings, which is called a string array. It is used to hold the command line arguments in the form of string values. The agrs[] is actually an array name, and it is of String type. It means that it can store a group of strings. Remember, this array can also store a group of numbers but in the form of a string only. Values passed to the main method are called arguments. These arguments are stored into args[] array, so the name args[] is generally used for it.

Now we are familiar with the terms used in the java main method, we are good to go and create a main method and run it. See the example below which prints out a message.

Passing arguments to Java main method

Passing arguments to the Java main method is a common way to provide input parameters to a Java application at the time of its execution. These arguments can be used to customize the behavior of the program, specify configuration settings, or provide input data.

Running Java file from using commands

To run the java file from the terminal, first, open the terminal and then using cd command and folder name, go the directory where the Java file is saved. Once you are in the same directory then use the following commands to run the java file. See the syntax below:

For example, let us say we have the following java program.

Now we will use the command line to run this program. See the result below:

Notice that the java program was run successfully.

Passing arguments to java main method through command line

We already learned how to run a java program using the terminal and commands. Now, we are good to pass arguments to the java main method using the terminal. The following is the simple syntax of passing arguments to the main method using the command line.

Now let us say we have the following java program which prints out the arguments of the main method. See the example java program below:

Now let us run the program using the command line. See the result below:

Notice that we successfully passed a string argument to the java main method and prints out using indexing.

Converting Arguments

In Java, when arguments are passed to the main method, they are received as an array of strings ( String[] args ). Depending on your program's needs, you might have to convert these strings into other data types or use them in specific ways.

To Integer:  To convert a string argument to an integer, you can use the parseInt method from the Integer class.

To Double : For decimal numbers, use the parseDouble method from the Double class.

To Boolean : The Boolean class provides a method parseBoolean which will return true for a string argument "true" (case insensitive), and false for anything else.

Checking for Specific String Values : You can compare string arguments with specific values using the equals method.

Using Arguments

As File Paths : Arguments can be used as paths to files or directories for reading/writing operations.

As Configuration Flags : You can use arguments to change the behavior or configuration of your program.

As Inputs for Operations : Arguments can directly be inputs for specific operations in your program.

Overloading the Java Main Method

In Java, method overloading is the practice of defining multiple methods in the same class with the same name but different parameters. Similarly, you can overload the main method. However, there are a few key points to understand:

1. JVM's Entry Point : The Java Virtual Machine (JVM) recognizes only one signature of the main method as the entry point of a Java program:

This is the method that gets executed when you run your Java class.

2. Overloading the Main Method : Even though JVM recognizes only the above signature as the entry point, nothing stops you from overloading the main method. Here are a couple of examples:

3. Invocation of Overloaded Methods : The overloaded main methods don't get executed automatically by the JVM. If you want them to run, you must call them explicitly from the standard main(String[] args) method or from some other method in your program:

4. Error Scenarios : Remember, if the JVM doesn't find the standard main(String[] args) signature in your class and you try to run it, you will get an error like:

Main Method without String[] args

The main method with the signature public static void main(String[] args) is conventional in Java because it's the entry point that the Java Virtual Machine (JVM) looks for when running a Java program. The String[] args parameter is designed to capture command-line arguments that might be passed to the program.

However, you can have a main method without String[] args , but there are some things to note:

If you have a main method like this:

The JVM won't recognize it as the entry point for your application . If you attempt to run the class directly, you'll get an error.

Such a main method can be invoked manually from another main method with the correct signature or any other static method in your program:

So, while it's technically possible to have a main method without the String[] args parameter, it's non-standard and won't serve as the entry point for your application.

Using varargs with Main Method

In Java, varargs (variable-length argument lists) is a feature that allows a method to accept zero or more arguments of a specific type. The syntax uses ellipses ( ... ) before the argument type.

The Java main method can also be declared using varargs.

However, using varargs, it can also be declared as:

Both declarations are valid, and the JVM recognizes both as valid entry points for a Java application.

The args parameter, whether declared as an array ( String[] ) or as varargs ( String... ), behaves as an array within the Java main method. Here's an example:

If you run this class with the command java VarargsMain Hello World , the output will be:

Why Isn't Varargs Used More Often in main ?

The standard String[] args is more commonly seen than the varargs version for a few reasons:

• Historical Precedence : Java's main method has traditionally used String[] args since before varargs were introduced (varargs came in Java 5).
• Clarity : While String... args and String[] args are functionally equivalent for the main method, the array notation is more familiar to most Java developers.
• Specific Use Case for Varargs : The primary benefit of varargs is when you have a method where you want to pass a variable number of arguments, potentially of different types. Since the main method always takes a sequence of strings, the traditional array notation is a clear and appropriate choice.

Why Java's Main Method is void?

The void keyword in Java's main method signature indicates that the method doesn't return any value. When looking at the signature:

The use of void might seem curious. However, the reasons for the main method being void in Java are grounded in design and utility.

The main method serves as the entry point for the Java Virtual Machine (JVM) when executing a Java application. After this method finishes executing, the Java application typically terminates (unless there are non-daemon threads still running). If the main method were to return a value, there would be a question of what the JVM would do with that returned value. In languages like C and C++, the main function returns an integer which can indicate the exit status of the program. However, Java took a different approach by handling program exit statuses using the System.exit(int status) method, which allows any part of a Java application to terminate the program with a given status.

Java provides a more flexible mechanism for setting exit status or performing cleanup operations. The System.exit(int status) method allows developers to exit from any part of the application and specify an exit status. Additionally, Java has a Runtime.addShutdownHook(Thread hook) method, which lets you add a thread as a shutdown hook. This hook will execute when the JVM is shutting down, allowing you to perform cleanup operations.

Absence of Return in Main Method

In Java, the main method's signature is defined as:

Here, void denotes that the main method doesn't return any value. This might lead to the question: What happens if you try to return a value or if you don't provide any return statement?

Since the Java main method is void , you are not required to include a return statement, and even if you do, it cannot return any value. The presence or absence of a return statement in a void method does not affect the compilation or execution of the program.

In a void method you can use a return statement by itself : This will simply exit the method prematurely.

In the above example, if no command-line arguments are provided, the program will print "No arguments provided." and exit without printing the second statement.

If you try to return a value, like return 1; , the compiler will throw an error because the main method is declared as void , which means it should not return any value.

Alternative Entry Points using the Java Launcher Tool

The traditional entry point for a Java application is the well-known public static void main(String[] args) method. However, starting from Java 9 with the introduction of the Java Platform Module System (JPMS), you can specify alternative entry points using the Java launcher tool. This is especially useful when working with modular applications.

1. @PostConstruct Annotation in Java EE:

In a Java EE (Enterprise Edition) environment, the @PostConstruct annotation can be used to designate a method that should be executed after dependency injection is done. While this isn't a replacement for the Java main method in standalone Java applications, it does serve as an entry point for initializing beans in a Java EE context.

2. Using the Provider Interface with Modules:

With the JPMS in Java 9 and later, you can use the java.util.spi.ToolProvider service provider interface to define custom tools that can be invoked by the Java launcher. Once you've defined a tool using this interface, you can run it using the Java launcher as follows:

Here, module.name is the name of the module providing the tool, and tool.name is the name of the tool.

3. public static int main(String[] args) :

While it's not a standard practice, the Java launcher tool can invoke a Java main method that returns an integer. This can serve as an alternative way to convey exit status directly from the main method, similar to languages like C and C++.

4. JavaFX Application:

In a JavaFX application, the primary entry point is the start method of the javafx.application.Application class, not the traditional Java main method. While you can still have a main method in your JavaFX application, it's the start method that's invoked by the JavaFX runtime to initialize and display the GUI.

Runtime Behavior Without a Main Method

In Java, the main method serves as the standard entry point for standalone applications. When a Java class containing a Java main method is executed using the Java interpreter, the JVM looks for this method to start the program. But what happens if this method is missing?

If There's No main Method at All:

If you try to execute a class using the Java interpreter (using the java command), and the class does not contain a Java main method, the JVM will raise an error. The error message you'll get is:

This indicates that the JVM couldn't find the standard entry point to start the application.

If the Java main Method Has an Incorrect Signature:

The signature of the main method is crucial. If the method is not public , not static , has a return type other than void , or takes parameters other than String[] , the JVM will consider it as an incorrect signature for the entry point.

For instance, if the main method is not public , you'll get an error like:

Class with Constructors but Without main :

If the class has constructors, but no Java main method, and you try to run the class, the constructors won't be invoked. This is because constructors are called when an instance of the class is created, but the JVM doesn't create an instance of the class when you run it using the java command. It just looks for the main method to execute.

Can You Compile a Class Without main ?:

Yes, you can. The Java compiler ( javac ) does not mandate the presence of the main method in a class for it to be compiled. The requirement for the main method is only enforced at runtime, not during compilation.

Runtime Behavior in Context of JavaFX:

JavaFX applications are an exception to this rule. In a JavaFX application, the primary entry point is the start method of a class that extends javafx.application.Application . If this method is present, you won't need a main method to run the JavaFX application.

Main Method in Nested and Inner Classes

In Java, it's possible to define a main method inside nested and inner classes, but invoking them is slightly different than with regular classes. Let's explore the possibilities:

1. Static Nested Class (often called a static inner class):

A static nested class is essentially a static member of the outer class. It can have static members, including the Java main method.

To run the main method of NestedStaticClass , you would use:

2. Inner (or Non-static Nested) Class:

Inner classes are associated with instances of the outer class and cannot have static members, except for constant variables (i.e., variables declared as static final ). Hence, you can't have a traditional Java main method in a non-static inner class.

However, with some clever workarounds like using an initializer block and a System.exit(0) , you can emulate a main -like method, but this is not idiomatic and can be confusing.

3. Local Inner Class:

Local inner classes are defined inside a block, typically within a method. They can't have static members, so they can't have a Java main method.

4. Anonymous Inner Class:

Anonymous inner classes are, well, anonymous. They're typically used for overriding methods on the fly, especially with interfaces or abstract classes. They can't have named methods, so they certainly can't have a main method.

Main Method Execution Sequence & Initialization Blocks

The execution sequence of the Java main method and initialization blocks in a Java class is an important concept, especially when it comes to understanding the initialization process of Java classes and objects. Here's a breakdown of the sequence:

1. Static Initialization Block:

Static initialization blocks are used for initializing static variables. These blocks get executed exactly once, when the class is loaded.

2. Initialization Block (also called Instance Initialization Block):

These blocks are executed every time an instance of the class is created. They run before the constructor and after the call to super() in the constructor.

3. Constructors:

Constructors initialize objects. They run after the instance initialization blocks.

Execution Sequence:

• When you run a Java program, the class containing the main method is loaded into memory, triggering the static initialization block (if present).
• Then, the Java main method is executed.
• If, inside the main method (or as a result of it being run), you create an instance of the class or any other class, the sequence becomes a bit more detailed:
• First, any static initialization blocks of the class being instantiated will run (but only the first time an object of the class is created, because it's when the class is first loaded).
• Next, the instance initialization blocks run.
• Finally, the constructor of the class is executed.

Let's put everything together:

When you run this program, the output will be:

When dealing with the main method in Java and understanding the sequence of initialization, it's important to follow best practices and draw concrete conclusions from our exploration.

• Central Entry Point : The main method serves as the principal entry point for Java applications. It's where the Java Virtual Machine (JVM) starts execution.
• Initialization Order Matters : The sequence of static and instance initialization blocks, constructors, and the main method is deterministic. This predictability helps developers ensure that dependencies and resources are initialized properly.
• Versatility : Overloading the main method, using varargs, and understanding alternatives like the Java Launcher Tool give developers flexibility, but they also add complexity. It's essential to know when and why to use these features.

Best Practices

• Keep main Simple : Aim to keep the main method concise and delegate tasks to other classes or methods. This helps in maintaining the code, making it more readable, and aids in unit testing.
• Avoid Overloading for main : While it's possible to overload the Java main method, it's generally not recommended. It can create confusion, especially for newcomers or when reading someone else's code.
• Initialization Order : Be aware of the initialization order (static blocks, instance blocks, constructors) to avoid null pointer exceptions or other runtime errors. Especially when static members depend on each other, their declaration order in the class can matter.
• Use main with Inner Classes Cautiously : While it's technically feasible to have a main method in inner or nested classes, it can be confusing. If you decide to use it, document why to make it clear for other developers.
• Respect Java Conventions : Stick to the standard signature public static void main(String[] args) . Even though the Java specification allows variations, sticking to conventions makes your code universally understandable.
• Handle Exceptions : Always handle exceptions properly in the Java main method. A sudden termination due to an unhandled exception can be confusing for users. At the very least, have a generic exception handler that provides meaningful error messages.

Further Reading

Java main method More about main method Java methods

Bashir Alam

He is a Computer Science graduate from the University of Central Asia, currently employed as a full-time Machine Learning Engineer at uExel. His expertise lies in Python, Java, Machine Learning, OCR, text extraction, data preprocessing, and predictive models. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can send mail to [email protected]

Thank You for your support!!

Leave a Comment Cancel reply

Save my name and email in this browser for the next time I comment.

Notify me via e-mail if anyone answers my comment.

We try to offer easy-to-follow guides and tips on various topics such as Linux, Cloud Computing, Programming Languages, Ethical Hacking and much more.

Recent Comments

Popular posts, 7 tools to detect memory leaks with examples, 100+ linux commands cheat sheet & examples, tutorial: beginners guide on linux memory management, top 15 tools to monitor disk io performance with examples, overview on different disk types and disk interface types, 6 ssh authentication methods to secure connection (sshd_config), how to check security updates list & perform linux patch management rhel 6/7/8, 8 ways to prevent brute force ssh attacks in linux (centos/rhel 7).

Privacy Policy

HTML Sitemap

• Java Tutorial
• What is Java?
• Installing the Java SDK
• Your First Java App

Java Main Method

• Java Project Overview, Compilation and Execution
• Java Core Concepts
• Java Syntax
• Java Variables
• Java Data Types
• Java Math Operators and Math Class
• Java Arrays
• Java String
• Java Operations
• Java if statements
• Java Ternary Operator
• Java switch Statements
• Java instanceof operator
• Java for Loops
• Java while Loops
• Java Classes
• Java Fields
• Java Methods
• Java Constructors
• Java Packages
• Java Access Modifiers
• Java Inheritance
• Java Nested Classes
• Java Record
• Java Abstract Classes
• Java Interfaces
• Java Interfaces vs. Abstract Classes
• Java Annotations
• Java Lambda Expressions
• Java Modules
• Java Scoped Assignment and Scoped Access
• Java Exercises

A Simple Java Class Declaration

The main() method, running the main() method, passing arguments to the main() method, the java main class.

A Java program is a sequence of Java instructions that are executed in a certain order. Since the Java instructions are executed in a certain order, a Java program has a start and an end.

To execute your Java program you need to signal to the Java Virtual Machine where to start executing the program. In Java, all instructions (code) have to be located inside a Java class . A class is a way of grouping data and instructions that belong together. Thus, a class may contain both variables and methods . A variable can contain data, and a method groups together a set of operations on data (instructions). Don't worry if you do not fully understand this yet. It will be explained in more details in later texts.

Declaring a simple class without any variables, methods or any other instructions, looks like this in Java code:

This Java code needs to be located in a file with the same file name as the class and ending with the file suffix .java . More specifically, the file name has to be MyClass.java . Once the file is located in a file matching its class name and ending with .java , you can compile it with the Java compiler from the Java SDK, or from inside your Java IDE (which is much easier).

It is recommended that you locate your class in a Java package . A Java package is simply a directory in your file system which can contain one or more Java files. Packages can be nested, just like directories can normally. For instance, you could create a package called myjavacode which would correspond to a directory on your hard drive with the name myjavacode .

If you locate a Java class inside a Java package, you have to specify the package name at the top of the Java file. Here is how the class from earlier looks with a package declaration added:

Note: The file MyClass.java must now be located in the directory myjavacode and contain the package declaration package myjavacode; . It is not enough that the Java file is located in the correct directory. Nor is it enough to just have the package declaration inside the Java file. Both requirements must be met.

A Java program needs to start its execution somewhere. A Java program starts by executing the main method of some class. You can choose the name of the class to execute, but not the name of the method. The method must always be called main . Here is how the main method declaration looks when located inside the Java class declaration from earlier:

The three keywords public , static and void have a special meaning. Don't worry about them right now. Just remember that a main() method declaration needs these three keywords.

After the three keywords you have the method name. To recap, a method is a set of instructions that can be executed as if they were a single operation. By "calling" (executing) a method you execute all the instructions inside that method.

After the method name comes first a left parenthesis, and then a list of parameters. Parameters are variables (data / values) we can pass to the method which may be used by the instructions in the method to customize its behaviour. A main method must always take an array of String objects. You declare an array of String objects like this:

Don't worry about what a String is, or what an array is. That will be explained in later texts. Also, it doesn't matter what name you give the parameter. In the main() method example earlier I called the String array parameter args , and in the second example I called it stringArray . You can choose the name freely.

After the method's parameter list comes first a left curly bracket ( { ), then some empty space, and then a right curly bracket ( } ). Inside the curly brackets you locate the Java instructions that are to be executed when the main method is executed. This is also referred to as the method body . In the example above there are no instructions to be executed. The method is empty.

Let us insert a single instruction into the main method body. Here is an example of how that could look:

Now the main method contains this single Java instruction:

This instruction will print out the text Hello World, Java Program to the console . If you run your Java program from the command line, then you will see the output in the command line console (the textual interface to your computer). If you run your Java program from inside an IDE, the IDE normally catches all output to the console and makes it visible to you somewhere inside the IDE.

When you start a Java program you usually do so via the command line (console). You call the java command that comes with the JRE, and tells it what Java class to execute, and what arguments to pass to the main() method. The Java application is then executed inside the JVM (or by the JVM some would claim). Here is a diagram illustrating this:

Here is an example command line:

The first part of this command is the java command. This command starts up the JVM. In some cases you may have to specify the full path to where the java command is located on your computer (typically inside the bin subdirectory of the Java install dir).

The second and third arguments ( -cp classes ) tells the JVM in what directory the compiled Java classes are located (cp means class path). In this case the compiled Java classes are located in a directory named classes .

The fourth argument is the name of the Java class the JVM is to execute. Notice how the class name also contains the name of the package the class is located in (the "fully qualified class name").

You can pass arguments from the command line to the main() method. This command line shows how:

When the JVM executes the main() method of the myjavacode.MyClass , the String array passed as parameter to the main() method will contain two Strings: "Hello" and "World".

The main() method can access the arguments from the command line like this:

Notice the references to element 0 and element 1 in the args array ( args[0] and args[1] ). args[0] will contain the String (text) Hello and args[1] will contain the String World .

Compiling and running Java source code is explained in more detail in the text Java Project Overview, Compilation and Execution .

Variables and arrays will be explained in more detail in later texts. Don't worry if you don't fully understand them at this point.

If only a single Java class in your Java program contains a main() method, then the class containing the main() method is often referred to as the main class .

You can have as many classes as you want in your project with a main() method in. But, the Java Virtual Machine can only be instructed to run one of them at a time. You can still call the other main() methods from inside the main() method the Java Virtual Machine executes (you haven't seen how yet) and you can also start up multiple virtual machines which each execute a single main() method.

Java Tutorial

Java methods, java classes, java file handling, java how to's, java reference, java examples, java class methods.

You learned from the Java Methods chapter that methods are declared within a class, and that they are used to perform certain actions:

Create a method named myMethod() in Main:

myMethod() prints a text (the action), when it is called . To call a method, write the method's name followed by two parentheses () and a semicolon ;

Inside main , call myMethod() :

Try it Yourself »

Method Parameters

Methods can also have parameters, which is used to pass information:

Create a method that accepts an int parameter called x. In the main() method, we call myMethod() and set an int parameter of 10:

Static vs. Public

You will often see Java programs that have either static or public attributes and methods.

In the example above, we created a static method, which means that it can be accessed without creating an object of the class, unlike public , which can only be accessed by objects:

An example to demonstrate the differences between static and public methods :

Note: You will learn more about these keywords (called modifiers) in the Java Modifiers chapter.

Access Methods With an Object

Create a Car object named myCar . Call the fullThrottle() and speed() methods on the myCar object, and run the program:

Example explained

1) We created a custom Main class with the class keyword.

2) We created the fullThrottle() and speed() methods in the Main class.

3) The fullThrottle() method and the speed() method will print out some text, when they are called.

4) The speed() method accepts an int parameter called maxSpeed - we will use this in 8) .

5) In order to use the Main class and its methods, we need to create an object of the Main Class.

6) Then, go to the main() method, which you know by now is a built-in Java method that runs your program (any code inside main is executed).

7) By using the new keyword we created an object with the name myCar .

8) Then, we call the fullThrottle() and speed() methods on the myCar object, and run the program using the name of the object ( myCar ), followed by a dot ( . ), followed by the name of the method ( fullThrottle(); and speed(200); ). Notice that we add an int parameter of 200 inside the speed() method.

Remember that..

The dot ( . ) is used to access the object's attributes and methods.

To call a method in Java, write the method name followed by a set of parentheses () , followed by a semicolon ( ; ).

A class must have a matching filename ( Main and Main.java ).

Advertisement

Using Multiple Classes

Like we specified in the Classes chapter , it is a good practice to create an object of a class and access it in another class.

Remember that the name of the java file should match the class name. In this example, we have created two files in the same directory:

Second.java

When both files have been compiled:

Run the Second.java file:

And the output will be:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• All Articles List
• 11 January 2023

Java main() Method

What is the java main() method, the main() method modifiers.

String[] args

The Java Main Method

In Java, you need to have a method named main in at least one class. The following is what must appear in a real Java program.

This method must appear within a class, but it can be any class. So here is the above main method enclosed in a class called Temporary. This would normally be in a file named Temporary.java. Your class should implement the Directions interface so that words like North are understood. We also put all of our files into the kareltherobot package so that all features of the UrRobot class are available. So here is a complete version of the file Temporary.java:

For those wanting explanation of some of the Java words here we provide the following somewhat simplified definitions.

A Java package is a way to collect different parts of a large program together logically. The Java system (JDK or Java Development Kit) comes with several packages of its own, but you can create your own. The name kareltherobot was created by the authors of the simulator for Karel J. Robot as a convenient place in which to collect robot programming code.

In Java the qualifier public means that something is available across packages. It is also possible to restrict visibility of names like Temporary to a single package or even more, but here we make it public.

The particular form of main is required by Java. While the following explanation of its parts is not needed now, and probably not especially understandable, you can return to it later when you know more.

In Java, main is a static method. This means the method is part of its class and not part of objects. Robots are objects. They are defined by classes, which are like factories for the creation of objects. In terms of our metaphor for robot programming, a static method is like the instructions read to robots by the helicoptor pilot, not the instructions known by the robots themselves. We will see ordinary (instance) methods in the Chapter 3.

Strings in Java are sequence of characters, like the characters in this sentence. The matched brackets indicate that an array of Strings is required. An array is a certain kind of linear collection of things. The name args is just a name for this array. This name is the only part of the declaration of main that can vary.

The declaration (String [] args) is in parentheses as part of the declaration of main to indicate that when the class Temporary is executed by your computer's operating system, an array of strings can be sent to the program to help with program initialization. Since they are not referenced again in the body of main (the part between braces {...}) they won't be used here. The parentheses, like the rest, are required. There is no space between [ and ].

Braces { and } are used to collect statements into a "block" in Java and in some other programming languages. Statements in Java end with semicolons.

To execute the above program you first need to translate it into a machine readable form using the Java compiler. Then you need to use the Java run-time to execute the machine readable version. When you do this you give the run time the name of the class that contains your main method.

Since the above is a bit arcane, we would like to simplify it if we can. The Karel J. Robot simulation program provided with the book has a built in class named KarelRunner that has a special kind of main. If you use this technique then KarelRunner will always be your main and always be the class you name to the Java run time.

Then, when you want to write a robot program, create a class like the following. It should be called GetBeeper.java, since it defines a class called GetBeeper. In Java the name of a public class is in a file with the same name and java for an extension. The name of the file and the name of its public class need to match. The name you give to your class and its file should probably be related to the problem you are trying to solve. Here we are trying to get a beeper. Also, in Java, the convention is that class names begin with a capital letter and method names do not.

Your class needs to implement RobotTask so that the other class, RobotRunner knows how to interpret this and run the task method here. Note that task here is NOT a static method.

In the book we often speak of the "main task block." You can interpret this to either mean a static main method as in the first example above, in which your class implements Directions, or as a task method in some class that implements RobotTask. Either will serve, though the latter is a bit easier to use.

Compiling and Executing Robot Code

Once you have a complete Robot program (or any Java program) you will want to execute it to see its effect. This is a two step process. First you must "build" your program and then "execute" it. If you have a Java environment like Eclipse or JBuilder, you create a "project" in the environment and add your files to it. This will include any code you write as well as the robot simulator code that you can get from the authors. Then it is just a matter of pushing buttons or selecting menu options to build and execute.

However, if you do not have an environment to work with then you need to use the JDK (Java Development Kit) from Sun Microsystems. You can get this from http://java.sun.com. You create your robot programs with a text editor and make sure that the file names end in ".java". The build step is then carried out by the "Java compiler" called javac. A command to do this would be something like

This assumes you are working in a Windows environment and have established a working directory with all of your files. On a unix system (including Macintosh OS X) the semicolon would be replaced by a colon. This command is typed into a command window on your computer.

If there are no errors in your program then (for robot programs) a new directory will be created called kareltherobot and it will contain the machine readable versions of your program in one or more "class" files.

Once you have done the above, you can execute your program with the "Java Virtual Machine", java. The command would look like this.

The command is case sensitive. You may be able to abbreviate classpath in the above with cp instead. This latter instruction tells java to look in the kareltherobot directory for the file GetBeeper.class and execute the main that it finds there.

All of the above is needed and must appear just about as shown. In particular you need the -classpath option followed by what is shown above as well as the -d option followed by a space and a period in the compile instruction.

In the next chapter we will see that it is possible to have many files to compile. You can do this all at once just by including them all where we have shown GetBeeper.java. Just include a list of filenames in the javac instruction separated by spaces.

In the java command, however, you always name just one class, the one that contains the main that you want to execute.

Note that I assumed in the above that the simulator for robot programs is called KarelJRobot.jar, which is true when this is written. Jar stands for "Java archive". It must be included both when you compile and when you execute (or "run") your robot program. For Java programs other than robot programs, you don't need this file.

Reasons to Create a Separate Class for the Main Method in Java

Degui Adil / EyeEm / Getty Images

• Java Programming
• PHP Programming
• Javascript Programming
• Delphi Programming
• C & C++ Programming
• Ruby Programming
• Visual Basic
• M.A., Advanced Information Systems, University of Glasgow

All Java programs must have an entry point, which is always the main() method. Whenever the program is called, it automatically executes the main() method first.

The main() method can appear in any class that is part of an application, but if the application is a complex containing multiple files, it is common to create a separate class just for main(). The main class can have any name, although typically it will just be called "Main".

What Does the Main Method Do?

The main() method is the key to making a Java program executable. Here is the basic syntax for a main() method:

Note that the main() method is defined within curly braces and is declared with three keywords: public, static and void :

• public : This method is public and therefore available to anyone.
• static : This method can be run without having to create an instance of the class MyClass.
• void : This method does not return anything.
• (String[] args) : This method takes a String argument. Note that the argument args can be anything — it's common to use "args" but we could instead call it "stringArray".

Now let's add some code to the main() method so that it does something:

This is the traditional "Hello World!" program, as simple as it gets. This main() method simply prints the words "Hello World!" In a real program , however, the main() method just starts the action and does not actually perform it.

Generally, the main() method parses any command line arguments, does some setup or checking, and then initializes one or more objects that continue the work of the program. 

Separate Class or Not?

As the entry point into a program, the main() method has an important place, but programmers do not all agree on what it should contain and to what degree it should be integrated with other functionality.

Some argue that the main() method should appear where it intuitively belongs — somewhere at the top of your program. For example, this design incorporates main() directly into the class that creates a server:

However, some programmers point out that putting the main() method into its own class can help make the Java components you are creating reusable. For example, the design below creates a separate class for the main() method, thus allowing the class ServerFoo to be called by other programs or methods:

Elements of the Main Method

Wherever you place the main() method, it should contain certain elements since it is the entry point to your program. These might include a check for any preconditions for running your program.

For example, if your program interacts with a database, the main() method might be the logical place to test basic database connectivity before moving on to other functionality.

Or if authentication is required, you would probably put the login information in main().

Ultimately, the design and location of main() are completely subjective. Practice and experience will help you determine where best to put main(), depending on the requirements of your program. 

• Static Fields in Java
• Designing and Creating Objects in JavaScript
• How to Create Your First Java Program
• Using Command-Line Arguments in a Java Application
• Using Multiple Main Classes
• A KeyListener Example Program With Java Code
• Three Types of Exceptions in Java
• Using Java Comments
• The Java Constructor Method
• Java: A Progress Bar Example Program
• Create a Simple Window Using JFrame
• Common Java Runtime Errors
• How to Use a Constant in Java
• Learn the Use of this() and (super) in Java Constructor Chaining
• Reserved Words in Java
• Example Java Code For Building a Simple GUI Application

Java Object Class

Java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial

Understanding Method Overloading vs. Method Overriding

Dive deep into Java programming with this comprehensive video tutorial exploring the intricate differences between method overloading and method overriding. Discover how these fundamental concepts drive the flexibility and extensibility of object-oriented programming in Java.

What You Will Learn

1. differentiating method overloading and method overriding.

• Gain insights into the core distinctions between method overloading and method overriding in Java.
• Understand how each concept contributes to code organization, maintenance, and scalability.

2. Exploring Practical Examples

• Dive into practical examples illustrating method overloading and method overriding in real-world scenarios.
• Explore hands-on demonstrations showcasing the application of these concepts for solving programming challenges effectively.

3. Common Use Cases

• Explore a variety of common use cases where method overloading and method overriding are essential.
• Learn how these concepts enhance code clarity, readability, and maintainability in Java projects.

4. Best Practices and Guidelines

• Master best practices and guidelines for effectively utilizing method overloading and method overriding.
• Discover strategies for optimizing code performance and minimizing potential errors and pitfalls.

5. Error Handling and Debugging

• Navigate common errors and challenges encountered during the implementation of method overloading and method overriding.
• Implement effective error handling strategies to ensure robust and reliable Java code.

Further Resources and In-Depth Insights

For a comprehensive guide and additional insights, watch the full video on GeeksforGeeks: https://www.geeksforgeeks.org/difference-between-method-overloading-and-method-overriding-in-java/  

This Java video tutorial equips you with the knowledge and skills to master method overloading and method overriding, empowering you to write clean, efficient, and maintainable Java code.

• Skip to content
• Accessibility Policy
• QUICK LINKS
• Oracle Cloud Infrastructure
• Oracle Fusion Cloud Applications
• Oracle Database
• Download Java
• Careers at Oracle

• Create an Account

Java Is the Language of Possibilities

Java is powering the innovation behind our digital world. Harness this potential with Java resources for student coders, hobbyists, developers, and IT leaders.

Newest Downloads

• Java SE 22.0.1
• Java SE 21.0.3 (LTS)
• Java SE 17.0.11 (LTS)
• Java SE 11.0.23 (LTS)
• Java SE 8u411

Technologies

What's new in java.

Join Oracle for the online developer event series to advance your coding skills

Learn more: Introducing Java SE 21

Learn more about the OpenJDK Project

• The Java Source Blog

Sharing the Code: 25 Years of Java Engagement

With the 25th birthday celebration of Java, learn about the programs that continue to keep the technology vibrant.

GraalVM Adds Value to the Java SE Subscription

Learn more about the entitlement of GraalVM Enterprise at no additional cost with the purchase of Java SE Subscription.

Java Voted as the Favorite Programming Language

Learn more about the recent DZone Audience Awards where Java was voted as the favorite programming language.

Read the blog

Essential Links

• Technical Articles
• Developer Resources
• Java Certification and Training
• Java Bug Database
• Java Developer Newsletter
• Demos and videos
• Community Platform
• Java User Groups
• Java Champions
• Java Community Process

Explore More