Czy główny jest prawidłowym identyfikatorem Java?

Jedno z moich dzieci bierze Javę w szkole średniej i miało to na jednym ze swoich testów:

Który z poniższych elementów jest prawidłowym identyfikatorem w Javie?

za. 123java
b. main
do. java1234
re. {abce
mi. )whoot

Odpowiedział b i pomylił się.

Spojrzałem na pytanie i argumentowałem, że main jest to prawidłowy identyfikator i że powinien był mieć rację.

Przyjrzeliśmy się specyfikacji Java dla identyfikatorów i to wzmocniło ten punkt. Napisaliśmy również przykładowy program, który miał zmienną o nazwie main, a także metodę. Stworzył pisemne obalenie, które zawierało odniesienie do dokumentacji Java, program testowy i nauczyciel zignorowali go i stwierdzili, że odpowiedź jest nadal nieprawidłowa.

Czy mainprawidłowy identyfikator?

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

To kompiluje, a po uruchomieniu emituje następujące dane wyjściowe:

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

Sekwencja znaków mainjest identyfikatorem, a nie słowem kluczowym ani słowem zastrzeżonym.

Istotne odcinek JLS 3.8 :

identyfikator jest sekwencją nieograniczonej długości liter Java i cyfr w języku Java , z których pierwszy musi być literą Java .

Identyfikator:

    IdentifierChars, ale nie słowo kluczowe, BooleanLiteral lub NullLiteral

Identyfikator:

    JavaLetter {JavaLetterOrDigit}

JavaLetter:

    dowolny znak Unicode będący „literą Java”

JavaLetterOrDigit:

    dowolny znak Unicode, który jest „literą lub cyfrą Java”

Sekwencja znaków mainpasuje do powyższego opisu i nie znajduje się na liście słów kluczowych w Rozdziale 3.9 .

(Sekwencja znaków java1234jest również identyfikatorem, z tych samych powodów.)

main jest prawidłowym identyfikatorem Java, a nauczyciel się myli.

Odpowiednia dokumentacja znajduje się w specyfikacji języka Java, tutaj:

Rozdział 3. „Struktura leksykalna”, sekcja 3.8. „Identyfikatory”:

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

To mówi:

Identyfikator jest sekwencją liter Java i cyfr Java o nieograniczonej długości, z których pierwsza musi być literą Java ... Identyfikator nie może mieć takiej samej pisowni (sekwencji znaków Unicode) jak słowo kluczowe (§3.9), literał logiczny ( §3.10.3) lub literału zerowego (§3.10.7) lub występuje błąd kompilacji.

Co oznacza, że ​​możesz udowodnić, że jest to prawidłowy identyfikator poprzez:

• szukając go na liście słów kluczowych java (wskazówka: nie znajdziesz go tam!) lub po prostu przez
• użycie go jako identyfikatora i zauważenie, że nie wystąpił błąd czasu kompilacji.

Jak podają inne odpowiedzi

mainjest poprawnym identyfikatorem Java , a także java1234.

Myślę, że zamieszanie wynika z faktu, że main(String[])JVM ¹ często stosuje tę metodę jako punkt wejścia . Nie oznacza to jednak, że mainsam token nie może być używany jako identyfikator ² .

Specyfikacja tak mówi i obowiązują również następujące deklaracje:

• Pole:

  private int main;

• Zmienna lokalna:

  String main = "";

• Metoda:

  private void main() { ... }

• Klasa (chociaż nazwa klasy zaczynająca się od małych liter jest odradzana):

  public class main { ... }

• Paczka:

  package main;

^{1: Jak zauważono w komentarzach, sama specyfikacja JVM nie nakazuje żadnej konkretnej metody jako punktu wejścia, ale powszechnie używane javanarzędzie często stosuje taką metodę jako punkt wejścia.
2: Zasadniczo unikałbym tworzenia głównej metody innej niżmain(String[]) .}

Kompiluje się dobrze w Javie 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);
    }
}

... a po wykonaniu generuje dane wyjściowe:

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

Rzuciłem w to wszystko, co mogłem, i wydaje się, że działa. Powiedziałbym, że main jest prawidłowym identyfikatorem.

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

Jak mainnie można go użyć jako identyfikatora, gdy jest używany jako identyfikator do deklarowania metody „głównej”?

Dla takiego klasycznego idiomu:

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

main nie jest słowem kluczowym i prawdopodobnie nigdy nie będzie słowem kluczowym w Javie z oczywistych powodów kompatybilności retro.

Jeśli chodzi o pytanie, czy jest mainto dobry identyfikator?

Po pierwsze: poprawne dla kompilatora niekoniecznie musi oznaczać dobre.
Na przykładjava1234 proponowana opcja jest również prawidłowym identyfikatorem, ale tak naprawdę należy jej unikać.

mainma bardzo szczególne i ważne znaczenie: jest stosowany jako metoda wejścia klas i słoików wykonywanych przez javawiersz poleceń.
Użycie mainnazwy metody, która nie spełnia kryteriów używanych w javawierszu poleceń, byłoby po prostu mylące, gdy używałaby jej jako nazwy zmiennej lub nazwy klasy może mieć sens.
Na przykład zdefiniowanie klasy reprezentującej punkt wejścia aplikacji jako Mainklasy aplikacji jest dopuszczalne, dlatego też użycie jej jako nazwy zmiennej, takiej jak:

public class Main {

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

}

Ogólnie rzecz biorąc, w Javie wiele znaków lub „słów” jest uważanych za prawidłowe identyfikatory kompilatora, ale zdecydowanie odradza się ich stosowanie w kodzie klienta (ale generowany kod może to zrobić: na przykład klasy zagnieżdżone) jako nieczytelne i / lub naprawdę wprowadzające w błąd.

Na przykład może to być poprawne dla kompilatora:

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

Ale nie chcemy:

• nazwać Objectnaszą klasę zgodnie z definicją w java.lang(1).
• nazwać metodę, main()jeśli nie spełnia kryteriów, które mają być użyte w javalinii poleceń (2).
• przeładować Object.toString()metodę (3).
• aby wymienić nasze zmienne z _, $ani żadnych zaskakujących / unmeaningful znaki, które wykraczają przeciwko współdzielonych konwencji nazewnictwa (4).

Czy to prawidłowy identyfikator? Tak.

Czy to dobry identyfikator? Nie, jeśli używasz go do czegoś innego niż metoda, która zaczyna się przy uruchomieniu JVM.

Czy wymieniono inny prawidłowy identyfikator? Tak.

Czy instrukcje testowe mówiły, aby wybrać najlepszą odpowiedź?

mainjest całkowicie poprawny, ponieważ z dokumentów :

1. Jest „sekwencją liter Java i cyfr Java, z których pierwsza jest literą Java”
2. Nie jest słowem kluczowym
3. Nie jest literałem logicznym, tj. „Prawda” lub „fałsz”
4. Nie jest zerowy dosłownie

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

Nauczyciel popełnił niewielki błąd, zakładając, że main nie jest prawidłowym identyfikatorem lub po prostu źle sformułował pytanie. Prawdopodobnie chciał powiedzieć „dobry identyfikator”.
Ale ignorowanie argumentów swoich synów, a tym samym zniechęcanie do jego naukowego podejścia do sprawdzania odpowiedniej literatury (specyfikacji Java) i przeprowadzania eksperymentu (pisanie przykładowego programu) jest dokładnym przeciwieństwem tego, co powinien zrobić nauczyciel.

Zarówno maini java123są ważne identyfikatory, główny nie jest zarezerwowanym słów kluczowych, dlatego całkowicie dopuszczalne do użycia, o ile test idzie powinien dotarłeś punkt lub pół punktu przynajmniej.

1. Powinno być pojedyncze słowo. Oznacza to, że spacje nie są dozwolone.

   Przykład: mangopryka jest ważna, ale cena mango jest nieprawidłowa.

2. Powinien zaczynać się od litery (alfabetu), podkreślenia lub symbolu $.

   Przykład: cena, cena i cena w USD są ważnymi identyfikatorami.

3. Nie powinno być słowem kluczowym Java, ponieważ słowo kluczowe ma specjalne znaczenie dla kompilatora.

   Przykład: klasa lub nieważne itp.

4. Nie powinien zaczynać się od cyfry, ale cyfra może znajdować się na środku lub na końcu.

   Przykład: 5mangoescost jest niepoprawny, a mango5cost i mangocost5 są prawidłowe.

5. Długość identyfikatora w Javie może wynosić 65 535 znaków i wszystkie są znaczące. W identyfikatorach rozróżniana jest wielkość liter. Oznacza to, że zarówno mango, jak i mango są traktowane inaczej. Może zawierać wszystkie wielkie lub małe litery lub mieszaninę.

IDENTYFIKATOR : są to nazwy klas, nazwy metod, nazwy zmiennych ...

Ponieważ main nie jest słowem zastrzeżonym i zgodnie z powyższym wyjaśnieniem dotyczącym definiowania identyfikatora main jest ważnym identyfikatorem i java1234 również. Pozostałe opcje nie są ważne z powodu powyższego wyjaśnienia.