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é.
main
a 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 java
ligne de commande.
Utiliser main
pour un nom de méthode qui ne remplit pas les critères à utiliser par la java
ligne 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 Main
classe 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
Object
notre 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 java
ligne 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).