Le principal est-il un identifiant Java valide?

Un de mes enfants prend Java au lycée et l'a fait à l'un de ses tests:

Lequel des éléments suivants est un identifiant valide en Java?

une. 123java
b. main
c. java1234
ré. {abce
e. )whoot

Il a répondu b et s'est trompé.

J'ai examiné la question et j'ai fait valoir qu'il main s'agit d' un identifiant valide et qu'il aurait dû être exact.

Nous avons examiné la spécification Java pour les identificateurs et cela a renforcé ce point. Nous avons également écrit un exemple de programme qui avait une variable appelée main, ainsi qu'une méthode. Il a créé une réfutation écrite qui comprenait la référence de la documentation Java, le programme de test et l'enseignant l'a ignoré et dit que la réponse est toujours incorrecte.

Un mainidentifiant est -il valide?

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

Ceci compile, et une fois exécuté, émet cette sortie:

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

La séquence de caractères mainest un identifiant, pas un mot-clé ou un mot réservé.

La section pertinente du JLS est 3.8 :

Un identifiant est une séquence de lettres et de chiffres Java de longueur illimitée , dont la première doit être une lettre Java .

Identifiant:

    IdentifierChars mais pas un mot-clé ou BooleanLiteral ou NullLiteral

IdentifierChars:

    JavaLetter {JavaLetterOrDigit}

JavaLetter:

    tout caractère Unicode qui est une "lettre Java"

JavaLetterOrDigit:

    tout caractère Unicode qui est une «lettre ou chiffre Java»

La séquence de caractères maincorrespond à la description ci-dessus et ne figure pas dans la liste de mots - clés de la section 3.9 .

(La séquence de caractères java1234est également un identifiant, pour les mêmes raisons.)

main est un identifiant java valide et l'enseignant a tort.

La documentation pertinente se trouve dans la spécification du langage Java, ici:

Chapitre 3. "Structure lexicale", section 3.8. "Identifiants":

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

Ça dit:

Un identifiant est une séquence de lettres et de chiffres Java de longueur illimitée, dont la première doit être une lettre Java ... Un identifiant ne peut pas avoir la même orthographe (séquence de caractères Unicode) qu'un mot clé (§3.9), littéral booléen ( §3.10.3), ou le littéral nul (§3.10.7), ou une erreur de compilation se produit.

Ce qui signifie que vous pouvez prouver qu'il s'agit d'un identifiant valide soit par:

• le chercher dans la liste des mots-clés java (indice: vous ne le trouverez pas ici!) ou simplement par
• en l'utilisant comme identifiant et en observant qu'aucune erreur de compilation ne se produit.

Comme les autres réponses le disent

mainest un identifiant Java valide , ainsi que java1234.

Je suppose que la confusion vient du fait que la main(String[])méthode est souvent utilisée comme point d'entrée par la JVM ¹ . Cependant, cela ne signifie pas que le jeton mainlui-même ne peut pas être utilisé comme identifiant ² .

Les spécifications le disent et les déclarations suivantes sont également valables:

• Un champ:

  private int main;

• Une variable locale:

  String main = "";

• Une méthode:

  private void main() { ... }

• Une classe (bien qu'un nom de classe commençant par des minuscules soit déconseillé):

  public class main { ... }

• Un paquet:

  package main;

^{1: Comme indiqué dans les commentaires, la spécification JVM elle-même ne prescrit aucune méthode particulière comme point d'entrée, mais l' javaoutil largement utilisé utilise souvent une telle méthode comme point d'entrée.
2: J'éviterais généralement de créer une méthode principale autre que main(String[]).}

Cela compile très bien sur 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);
    }
}

... et une fois exécuté produit la sortie:

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

J'ai jeté tout ce que j'ai pu dessus, et ça semble marcher. Je dirais que principal est un identifiant valide.

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

Comment main ne pas être utilisé comme identifiant alors qu'il est utilisé comme identifiant pour déclarer la méthode "principale"?

Pour un idiome aussi classique:

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

main n'est pas un mot clé et il ne serait probablement jamais un mot clé en Java pour des raisons évidentes de rétrocompatibilité.

À propos de la question, est main un bon identifiant?

Premièrement: valide pour un compilateur ne signifie pas nécessairement bon.
Par exemple,java1234 option qui est proposée est également un identifiant valide mais cela devrait vraiment être évité.

maina une signification très particulière et importante: elle est utilisée comme méthode de point d'entrée des classes et des jars exécutés par la javaligne de commande.
Utiliser mainpour un nom de méthode qui ne remplit pas les critères à utiliser par la javaligne de commande serait tout simplement trompeur tout en l'utilisant comme nom de variable ou un nom de classe pourrait avoir un sens.
Par exemple, la définition de la classe représentant le point d'entrée d'une application comme Mainclasse de l'application est acceptable et donc son utilisation en tant que nom de variable, comme:

public class Main {

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

}

De manière générale, en Java, plusieurs caractères ou "mots" sont considérés comme des identifiants valides pour le compilateur mais sont fortement déconseillés pour être utilisés dans le code client (mais le code généré peut le faire: classes imbriquées par exemple) comme non lisibles et / ou vraiment trompeur.

Par exemple, cela pourrait être valide pour le compilateur:

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

Mais nous ne voulons pas:

• pour nommer Objectnotre classe comme cela est défini dans java.lang(1).
• pour nommer une méthode main()si ne remplit pas les critères à utiliser par la javaligne de commande (2).
• pour surcharger la Object.toString()méthode (3).
• pour nommer nos variables _, $ou tout caractère surprenant / sans signification qui va à l'encontre des conventions de nommage partagées (4).

Est-ce un identifiant valide? Oui.

Est-ce un bon identifiant? Pas si vous l'utilisez pour autre chose que la méthode qui démarre au lancement de la JVM.

Un autre identifiant valide est-il répertorié? Oui.

Les instructions du test indiquaient-elles de choisir la meilleure réponse?

mainest parfaitement valide car, d' après les documents :

1. Est une "séquence de lettres Java et de chiffres Java, dont la première est une lettre Java"
2. N'est pas un mot - clé
3. N'est pas un littéral booléen c'est-à-dire "vrai" ou "faux"
4. N'est pas littéral nul

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

L'enseignant a commis une erreur mineure en supposant que main n'est pas un identifiant valide ou en formulant simplement la question de manière erronée. Il voulait peut-être dire "un bon identifiant".
Mais ignorer les arguments de votre fils et décourager ainsi son approche scientifique de vérification de la littérature pertinente (spécification Java) et de réalisation d'une expérience (écriture d'un exemple de programme) est exactement le contraire de ce qu'un enseignant est censé faire.

Les deux mainet java123sont valides des identificateurs, principal n'est pas un mot - clé réservé de sorte qu'il est parfaitement acceptable d'utiliser, pour autant que le test va vous devez avoir obtenu un point ou un demi - point au moins.

1. Doit être un seul mot. Autrement dit, les espaces ne sont pas autorisés.

   Exemple: mangoprice est valide mais le prix de la mangue n'est pas valide.

2. Doit commencer par une lettre (alphabet) ou un trait de soulignement ou $.

   Exemple: prix, _ prix et $ prix sont des identifiants valides.

3. Ne doit pas être un mot clé de Java car le mot clé a une signification particulière pour le compilateur.

   Exemple: classe ou vide, etc.

4. Ne doit pas commencer par un chiffre mais le chiffre peut être au milieu ou à la fin.

   Exemple: 5mangoescost n'est pas valide et mango5cost et mangocost5 sont valides.

5. La longueur d'un identifiant en Java peut être de 65 535 caractères et tous sont significatifs. Les identificateurs sont sensibles à la casse. Cela signifie que la mangue et la mangue sont traitées différemment. Peut contenir toutes les lettres majuscules ou minuscules ou un mélange.

IDENTIFICATEUR : ce sont des noms de classe, des noms de méthode, des noms de variables ...

Comme principal n'est pas un mot réservé et selon l'explication ci-dessus pour définir un identifiant, principal est un identifiant valide et java1234 également.Les options restantes ne sont pas valides en raison de l'explication ci-dessus.