# `main()` and Command Line Argument | Java

To run every Java programme `main()` is necessary otherwise the programme would compile or run.

Whether class contains `main()` or not and whether mean is declared according to requirement or not these things wont cheque by compiler.

At runtime JVM is responsible to check these things. If JVM unable to find `main()` that will be get runtime exception i.e., `NoSuchMethod Error:main`

```java
class Test{
//No main() methods declared
}
```

At runtime JVM always searches for the main method with the following prototype -

`public stating void main (string[] args)`

* `public` is an access modifier, indicating that the main method can be accessed from outside the class.
    
* `static` keyword indicates that the method belongs to the class rather than an instance of the class. It is compulsory main method should be `static`. Without existing any object JVM has to call this method so static is used.
    
* The return type is `void` be because main method won't return anything to JVM.
    
* The `main` method is the entry point of a Java program. We cannot use any other name for main method because inside JVM main is the name which is configured that is why it is always search for main (method name).
    
* `string[] args` is the parameter list for the `main` method. It allows the program to accept command-line arguments. `String[] args` is an array of strings that holds any command-line arguments passed to the program.
    

The above syntax is very strict and if we perform any change then we will get runtime exception saying no such method error mean.

Even though above syntax is very strict the following changes are acceptable:

1. Instead of `public static` we can take `static public` that is <mark>order of identifier is not important</mark>.
    
2. We can declare string a day in acceptable form -
    

* `public static void main (string[] args)`
    

* `public static void main (string []args)`
    

* `public static void main (string args[])`
    

1. Instead of args we can take any valid Java identifier. For example - `public static void main(string[] vikas)`
    
2. We can replace `string[]` with `string... args` parameter i.e., `public static void main(string... args)`
    

We can declare main method with the following modifiers also i.e., `final`, `strictfp`, `synchronized`

```java
class Test{
    static final synchronized strictfp public void main(String... args){
        System.out.println("Hello World"); //Valid
    }
}
```

## Exceptional Cases in `main()`

### Case 1: Overloading of `main()`

* Overloading of build method is possible but JVM will always call `string[]` argument main method only.
    
* The other overloaded method we have to call explicitly just like a normal method.
    

```java
class Test{
    //default main method
    public static void main(String[] args){
        System.out.println("Hello World");
    }

    //overloaded main method
    public static void main(int[] args){
        System.out.println(10);
    }
}
```

### Case 2: Inheritance with `main()`

* Inheritance concept applicable for main method hence while executing child class if child class doesn't contain method then parent class bin method will be executed.
    

```java
class Parents{
    public static void main(String[] args){
        System.out.println("Parent Class");
    }
}

class Child extends Parents{
    //no main method
}
```

When will compile the parent's class, Chevrier will create two class files that is `child.class` and `parents.class`.

### Case 3: Overidding of `main()`

It seems overriding concept applicable for main method but it is not because its method hiding.

Method hiding is nothing but same method and passed argument but in different class.

```java
class Parents{
    public static void main(String[] args){
        System.out.println("Parent Class");
    }
}

class Child extends Parents{
    public static void main(String[] args){
        System.out.println("Child Class");
    }
}
```

## 1.7v Enhancement w.r.t `main()`

Until 1.6 version if class doesn't contain `main()` then we will get runtime exceptions saying `No suchMethod Error:main` but from 1.7 onwards instead of we get more elaborated error information instead i.e., `Error: Main method not found in class test please define main method as public static void main(String[] args)`

<mark>From 1.7 version onwards </mark> `main()` <mark> is mandatory to start programme execution</mark> hence even though class contains static block it wont be executed if the class doesn't contain `main()`.

# Command Line Argument

* The arguments which are passed from command line or command prompt are called command argument.
    
* With these JVM will create an array and by passing that array as argument JVM will call `main()`.
    

```java
class Test{
    public static void main(String[] args){
        //code
    }
}
```

```powershell
C:\> javac Test.java
C:\> java Test A B C
```

`args[0] = A`, `args[1] = B`, `args[2] = C`; `args.length` will be 3

The main objective of command and argument is bigger customise behaviour of main method.

Let's say we want to merge two files. So, instead of using fixed variable value if we can pass the name of file or any file name that will do it that will be more convenient.

Command arguments are always passed as a string because it is most common data type and <mark>can be converted in any data type using parsing</mark>.

## Exceptional Cases in Command line argument

### Case 1

```java
class Test{
    public static void main(String[] args){
        for(int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}
```

```powershell
C:\> javac Test.java
C:\> java Test A B C
Runtmie Exception: ArrayIndexOutOfBoundException
```

Compiler complaining due to `i<=args.length` to if it will be `i<args.length` then it will be fine and wont complain or get any runtime exception.

### Case 2

Usually space itself is the separator between command line argument.

in our command line arguments itself contains space then we have to enclose that command line argument within double quotes.

```java
class Test{
    public static void main(String[] args){
            System.out.println(args[0]);
    }
}
```

```powershell
C:\> javac Test.java
C:\> java Test "Note Book"
Note Book
C:\> java Test Note
Note
```

## Conclusion

Understanding Java main() essentials: Its importance, syntax rules, runtime role, and command-line arguments. Explore nuances like overloading, inheritance, and overriding, with a focus on clean coding practices. Delve into exceptional cases and the significance of main() in Java 1.7+. Embrace command-line arguments for customized program behaviour.