Is main a valid Java identifier?

One of my kids is taking Java in high school and had this on one of his tests:

> Which of the following is a valid identifier in Java? > > a. 123java
b. main
c. java1234
d. {abce
e. )whoot

He answered b and got it wrong.

I looked at the question and argued that main is a valid identifier and that it should have been right.

We took a look at the Java spec for identifiers and it reinforced that point. We also wrote a sample program that had a variable called main, as well as a method. He created a written rebuttal that included the Java documentation reference, the test program and the teacher ignored it and says the answer is still incorrect.

Is main a valid identifier?

public class J {
    public static void main(String[] args)
    {
        String main = "The character sequence \"main\" is an identifier, not a keyword or reserved word.";
        System.out.println(main);
    }
}

This compiles, and when executed, emits this output:

The character sequence "main" is an identifier, not a keyword or reserved word.

The character sequence main is an identifier, not a keyword or reserved word.

The relevant section of the JLS is 3.8:

> An identifier is an unlimited-length sequence of Java letters and Java digits, the first of which must be a Java letter. > > Identifier: > >     IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral > > IdentifierChars: > >     JavaLetter {JavaLetterOrDigit} > > JavaLetter: > >     any Unicode character that is a "Java letter" > > JavaLetterOrDigit: > >     any Unicode character that is a "Java letter-or-digit"

The character sequence main fits the above description and is not in the keyword list in Section 3.9.

(The character sequence java1234 is also an identifier, for the same reasons.)

main is a valid java identifier, and the teacher is wrong.

The relevant documentation is in the Java Language Specification, right here:

Chapter 3. "Lexical Structure", section 3.8. "Identifiers":

https://docs.oracle.com/javase/specs/jls/se10/html/jls-3.html#jls-3.8

It says:

> An identifier is an unlimited-length sequence of Java letters and Java digits, the first of which must be a Java letter... An identifier cannot have the same spelling (Unicode character sequence) as a keyword (§3.9), boolean literal (§3.10.3), or the null literal (§3.10.7), or a compile-time error occurs.

Which means that you can prove that it is a valid identifier either by:

• looking for it in the list of java keywords (hint: you won't find it there!) or simply by
• using it as an identifier and observing that no compile-time error occurs.

As the other answers state

main is a valid Java identifier, as well as java1234.

I guess the confusing comes from the fact that the main(String[]) method is often used as entry point by the JVM¹. However, that doesn't mean that the token main itself cannot be used as identifier².

The specs say so, and the following declarations are also valid:

• A field:

  private int main;
  

• A local variable:

  String main = "";
  

• A method:

  void main() { ... }
  

• A class or interface (although a class or interface name starting with lowercase is discouraged):

  class main { ... }
  

• A package:

  package main;
  

---

^{1: As noted in the comments, the JVM specification itself does not mandate any particular method as entry point, but the widely used java tool often uses such a method as entry point.
2: I would generally avoid creating a main method other than main(String[]).}

---

^{Addendum: I don't feel like this is the place to rant, but here is my correct humble opinion: the identifier main is just as valid as java1234, so both must be treated equally valid or wrong. Doing otherwise is intolerable.}

This compiles fine on Java 1.8...

public class main {

    public String main = "main"; 

    public void main(String main) {
        System.out.println("This object is an instance of the class " + this.getClass().getCanonicalName());
        System.out.println("The value of the argument \"main\" for this call to the method \"main(String main)\" is " + main);
        System.out.println("The value of the field \"main\" is " + this.main);
    }

    public static void main(String[] args) {
        main main = new main();
        main.main(main.main + main.main);
    }
}

...and when executed produces the output:

This object is an instance of the class main
The value of the argument "main" for this call to the method "main(String main)" is mainmain
The value of the field "main" is main

I threw everything I could at it, and it appears to work. I'd say main is a valid identifier.

package main;

public class main {

	static main main;
	String Main;
	
	main(String main) {
		Main = main;
	}
	
	main(main main) {
		System.out.println(main.Main);
	}
	
	main main(main main) {
		return new main(main);
	}
	
	public static void main(main...Main) {
		main:
		for (main main : Main) {
			main = (main instanceof Main) ? new main(main): main.main(main);
			break main;
		}
	}
	
	public static void main(String[] args) {
		main = new main("main");
		main.main(main, main);
		main = main.new Main(main) {
			main main(main main) {
				return ((Main)main).main();
			}
		};
		main.main(main);
		main.main(main,main);
	}
	
	abstract class Main extends main {
		Main(main main) {
			super("main");
		}
		
		main main() {
			main.Main = "Main";
			return main;
		}
	}
}

How main could not be used as an identifier while it is used as identifier to declare the "main" method ?

For such a classic idiom :

public class Foo{
   public static void main(String[] args){
   }
}

main is not a keyword and it would probably never be a keyword in Java for obvious retro compatibility reasons.

---

About the question, is main a good identifier ?

First : valid for a compiler doesn't mean necessarily good.
For example the java1234 option that is proposed is also a valid identifier but that should really be avoided.

main has a very particularly and important meaning : it is used as the entry point method of classes and jars executed by the java command line.
Using main for a method name that doesn't fill the criteria to be used by the java command line would be just misleading while using it as variable name or a class name could make sense.
For example defining the class representing the entry point of an application as the Main class of the application is acceptable and so using it as variable name too such as :

public class Main {

  public static void main(String args[]){
     Main main = new Main();
     // ...
  }      

}

In a general way, in Java, multiple characters or "words" are considered valid identifiers for the compiler but are strongly discouraged to be used in the client code (but generated code may do that : nested classes for example) as not readable and/or really misleading.

For example this could be valid for the compiler :

public class Object { // 1
	public void foo() {
       ...
	}
}

public class BadChosenIdentifier {

	public static void main() { // 2
		new BadChosenIdentifier().toString(new Object());  
	}

	public void toString(Object java1234) { // 3, 4
		String _result$ = java1234 + " -> to avoid"; // 4
		System.out.println(_result$);
	}    
}

But we don't want :

• to name Object our class as this is defined in java.lang(1).
• to name a method main() if doesn't fill the criteria to be used by the java command line (2).
• to overload the Object.toString() method (3).
• to name our variables with _, $ or any surprising/unmeaningful characters that go against the shared naming conventions (4).

Is it a valid identifier? Yes.

Is it a good identifier? Not if you're using it for anything other than the method that starts at JVM launch.

Is another valid identifier listed? Yes.

Did the test instructions say to choose the best answer?

main is perfectly valid because it, from the docs:

1. Is a "sequence of Java letters and Java digits, the first of which is a Java letter"
2. Is not a keyword
3. Is not a boolean literal i.e. "true" or "false"
4. Is not null literal

public class Main {
    private static String main;
    public static void main(String[] main) {
        Main.main = main[0];
        new Main().main(Main.main);
    }
    private void main(String main) {
        System.out.println(main);
    }
}

That teacher made a minor mistake in either assuming main is not a valid identifier or simply phrasing the question wrong. He possibly meant to say "a good identifier".
But ignoring your sons arguments and thereby discouraging his scientific approach of checking relevant literature (Java specification) and performing an experiment (writing a sample program) is the exact opposite of what a teacher is supposed to do.

Both main and java123 are valid identifiers, main isn’t a reserved keyword so it’s perfectly acceptable to use, as far as the test goes you should’ve gotten a point or half a point at least.

1. Should be single word. That is spaces are not allowed.

   Example: mangoprice is valid but mango price is not valid.

2. Should start with a letter (alphabet) or underscore or $ symbol.

   Example: price, _price and $price are valid identifiers.

3. Should not be a keyword of Java as keyword carries special meaning to the compiler.

   Example: class or void etc.

4. Should not start with a digit but digit can be in the middle or at the end.

   Example: 5mangoescost is not valid and mango5cost and mangocost5 are valid.

5. Length of an identifier in Java can be of 65,535 characters and all are significant. Identifiers are case-sensitive. That is both mango and Mango are treated differently. Can contain all uppercase letters or lowercase letters or a mixture.

IDENTIFIER: they are class names, method names, variable names ...

As main is not a reserved word and according to the explanation above for defining an identifier main is a valid identifier and java1234 also.Remaining options are not valid because of the above explanation.