Is main a valid Java identifier?

Question

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?

Answer 1

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:

  private void main() { ... }
  

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

  public 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[]).}

Answer 2

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).

Answer 3

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 by using it as an identifier and observing that no compile-time error occurs.

Answer 4

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.

Answer 5

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

Answer 6

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.