Main é um identificador Java válido?

Um dos meus filhos está cursando Java no ensino médio e fez isso em um de seus testes:

Qual das alternativas a seguir é um identificador válido em Java?

uma. 123java
b. main
c. java1234
d. {abce
e )whoot

Ele respondeu be entendeu errado.

Eu olhei para a pergunta e argumentei que main é um identificador válido e que deveria estar certo.

Examinamos a especificação Java para identificadores e isso reforçou esse ponto. Também escrevemos um programa de amostra que tinha uma variável chamada main, além de um método. Ele criou uma refutação por escrito que incluiu a referência da documentação Java, o programa de teste e o professor a ignorou e diz que a resposta ainda está incorreta.

É mainum identificador válido?

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);
    }
}

Isso compila e, quando executado, emite esta saída:

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

A sequência de caracteres mainé um identificador, não uma palavra-chave ou palavra reservada.

A seção relevante do JLS é 3.8 :

Um identificador é uma sequência de letras e dígitos Java ilimitada , a primeira das quais deve ser uma letra Java .

Identificador:

    IdentifierChars, mas não uma palavra-chave ou BooleanLiteral ou NullLiteral

IdentifierChars:

    JavaLetter {JavaLetterOrDigit}

JavaLetter:

    qualquer caractere Unicode que seja uma "letra Java"

JavaLetterOrDigit:

    qualquer caractere Unicode que seja "letra ou dígito Java"

A sequência de caracteres mainse encaixa na descrição acima e não está na lista de palavras - chave na Seção 3.9 .

(A sequência de caracteres java1234também é um identificador, pelos mesmos motivos.)

main é um identificador java válido e o professor está errado.

A documentação relevante está na Especificação da linguagem Java, aqui:

Capítulo 3. "Estrutura Lexical", seção 3.8. "Identificadores":

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

Diz:

Um identificador é uma sequência de tamanho e letras Java ilimitada, a primeira das quais deve ser uma letra Java ... Um identificador não pode ter a mesma ortografia (sequência de caracteres Unicode) que uma palavra-chave (§3.9), literal booleano ( §3.10.3), ou o literal nulo (§3.10.7), ou ocorre um erro em tempo de compilação.

O que significa que você pode provar que é um identificador válido:

• procurando na lista de palavras-chave java (dica: você não a encontrará lá!) ou simplesmente
• usando-o como um identificador e observando que nenhum erro em tempo de compilação ocorre.

Como as outras respostas declaram

mainé um identificador Java válido , bem como java1234.

Eu acho que a confusão vem do fato de que o main(String[])método é frequentemente usado como ponto de entrada pela JVM ¹ . No entanto, isso não significa que o mainpróprio token não possa ser usado como identificador ² .

As especificações dizem isso e as seguintes declarações também são válidas:

• Um campo:

  private int main;

• Uma variável local:

  String main = "";

• Um método:

  private void main() { ... }

• Uma classe (embora um nome de classe que comece com minúsculas seja desencorajado):

  public class main { ... }

• Um pacote:

  package main;

^{1: Conforme observado nos comentários, a própria especificação da JVM não exige nenhum método específico como ponto de entrada, mas a javaferramenta amplamente usada geralmente usa esse método como ponto de entrada.
2: Eu geralmente evitaria criar um método principal diferente de main(String[]).}

Isso compila bem no 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);
    }
}

... e quando executado produz a saída:

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

Joguei tudo o que pude e parece que funciona. Eu diria que main é um identificador válido.

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;
        }
    }
}

Como mainnão pôde ser usado como identificador enquanto é usado como identificador para declarar o método "principal"?

Para um idioma tão clássico:

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

main não é uma palavra-chave e provavelmente nunca seria uma palavra-chave em Java por razões óbvias de compatibilidade retroativa.

Sobre a pergunta, é mainum bom identificador?

Primeiro: válido para um compilador não significa necessariamente bom.
Por exemplo, a java1234opção proposta também é um identificador válido, mas que realmente deve ser evitado.

maintem um significado muito particular e importante: é usado como o método de ponto de entrada de classes e jarros executados pela javalinha de comando.
Usar mainum nome de método que não preencha os critérios a serem usados ​​pela javalinha de comando seria enganoso, mas usá-lo como nome de variável ou nome de classe pode fazer sentido.
Por exemplo, definir a classe que representa o ponto de entrada de um aplicativo como a Mainclasse do aplicativo é aceitável e, portanto, usá-lo também como nome de variável, como:

public class Main {

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

}

De maneira geral, em Java, vários caracteres ou "palavras" são considerados identificadores válidos para o compilador, mas são fortemente desencorajados a serem usados ​​no código do cliente (mas o código gerado pode fazer isso: classes aninhadas por exemplo) como não legíveis e / ou realmente enganoso.

Por exemplo, isso pode ser válido para o compilador:

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$);
    }    
}

Mas nós não queremos:

• para nomear Objectnossa classe, conforme definido em java.lang(1).
• nomear um método main()se não preencher os critérios a serem usados ​​pela javalinha de comando (2).
• sobrecarregar o Object.toString()método (3).
• para citar nossos variáveis com _, $ou quaisquer caracteres surpreendentes / unmeaningful que vão contra as convenções de nomenclatura comum (4).

É um identificador válido? Sim.

É um bom identificador? Não se você o estiver usando para algo diferente do método iniciado no lançamento da JVM.

Há outro identificador válido listado? Sim.

As instruções do teste disseram para escolher a melhor resposta?

mainé perfeitamente válido porque, nos documentos :

1. É uma "sequência de letras e dígitos Java, o primeiro dos quais é uma letra Java"
2. Não é uma palavra - chave
3. Não é um literal booleano, ou seja, "verdadeiro" ou "falso"
4. Não é literal nulo

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);
    }
}

Esse professor cometeu um pequeno erro ao supor que main não é um identificador válido ou simplesmente colocar a pergunta errada. Ele possivelmente quis dizer "um bom identificador".
Mas ignorar os argumentos de seus filhos e, assim, desencorajar sua abordagem científica de verificar literatura relevante (especificação Java) e realizar um experimento (escrever um programa de amostra) é exatamente o oposto do que um professor deve fazer.

Ambos maine java123são identificadores válidos , main não é uma palavra-chave reservada, por isso é perfeitamente aceitável de usar; no que diz respeito ao teste, você deveria ter conseguido um ponto ou meio ponto pelo menos.

1. Deve ser uma palavra. Ou seja, espaços não são permitidos.

   Exemplo: o mangoprice é válido, mas o preço da manga não é válido.

2. Deve começar com uma letra (alfabeto) ou sublinhado ou $.

   Exemplo: price, _price e $ price são identificadores válidos.

3. Não deve ser uma palavra-chave do Java, pois a palavra-chave carrega um significado especial para o compilador.

   Exemplo: classe ou nulo etc.

4. Não deve começar com um dígito, mas o dígito pode estar no meio ou no final.

   Exemplo: 5mangoescost não é válido e mango5cost e mangocost5 são válidos.

5. O comprimento de um identificador em Java pode ter 65.535 caracteres e todos são significativos. Identificadores diferenciam maiúsculas de minúsculas. Isso é manga e manga são tratadas de maneira diferente. Pode conter todas as letras maiúsculas ou minúsculas ou uma mistura.

IDENTIFICADOR : são nomes de classe, nomes de métodos, nomes de variáveis ​​...

Como main não é uma palavra reservada e, de acordo com a explicação acima para definir um identificador, main é um identificador válido e java1234 também. As opções restantes não são válidas devido à explicação acima.