main เป็นตัวระบุ Java ที่ถูกต้องหรือไม่

ลูกคนหนึ่งของฉันเรียน Java ในโรงเรียนมัธยมและได้รับสิ่งนี้จากการทดสอบของเขา:

ข้อใดต่อไปนี้เป็นตัวระบุที่ถูกต้องใน Java

ก. 123java
ข. main
ค. java1234
ง. {abce
จ. )whoot

เขาตอบbและเข้าใจผิด

ฉันดูคำถามและโต้แย้งว่าmain เป็นตัวระบุที่ถูกต้องและควรจะถูกต้อง

เราดูข้อมูลจำเพาะ Java สำหรับตัวระบุและเสริมจุดนั้น นอกจากนี้เรายังเขียนโปรแกรมตัวอย่างที่มีการเรียกตัวแปรmainเช่นเดียวกับวิธีการ เขาสร้างข้อโต้แย้งที่เป็นลายลักษณ์อักษรซึ่งรวมถึงการอ้างอิงเอกสาร Java โปรแกรมทดสอบและครูเพิกเฉยและบอกว่าคำตอบยังไม่ถูกต้อง

คือmainตัวระบุที่ถูกต้อง?

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

สิ่งนี้คอมไพล์และเมื่อเรียกใช้งานจะปล่อยเอาต์พุตนี้:

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

ลำดับอักขระmainเป็นตัวระบุไม่ใช่คำหลักหรือคำสงวน

ส่วนที่เกี่ยวข้องของ JLS คือ 3.8 :

ระบุเป็นลำดับไม่ จำกัด ความยาวของตัวอักษร Javaและตัวเลข Javaแรกของการที่จะต้องเป็นตัวอักษร Java

ตัวระบุ:

    IdentifierChars แต่ไม่ใช่ Keyword หรือ BooleanLiteral หรือ NullLiteral

ตัวระบุ

    JavaLetter {JavaLetterOrDigit}

JavaLetter:

    อักขระ Unicode ใด ๆ ที่เป็น "ตัวอักษร Java"

JavaLetterOrDigit:

    อักขระ Unicode ใด ๆ ที่เป็น "Java letter-or-digit"

ลำดับตัวอักษรmainพอดีคำอธิบายข้างต้นและไม่ได้อยู่ในรายการคำหลักในมาตรา 3.9

(ลำดับอักขระjava1234ยังเป็นตัวระบุด้วยเหตุผลเดียวกัน)

main เป็นตัวระบุจาวาที่ถูกต้องและครูไม่ถูกต้อง

เอกสารที่เกี่ยวข้องอยู่ในข้อกำหนดภาษา Java ที่นี่:

บทที่ 3 "โครงสร้างคำศัพท์" ตอนที่ 3.8 "ตัวระบุ":

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

มันบอกว่า:

ตัวระบุคือลำดับความยาวไม่ จำกัด ของตัวอักษร Java และตัวเลข Java ตัวแรกต้องเป็นตัวอักษร Java ... ตัวระบุไม่สามารถมีการสะกดเหมือนกัน (ลำดับอักขระ Unicode) เป็นคีย์เวิร์ด (§3.9) ลิเทอรัลบูลีน ( §3.10.3) หรือลิเทอรัลว่าง (§3.10.7) หรือเกิดข้อผิดพลาดเวลาคอมไพล์

ซึ่งหมายความว่าคุณสามารถพิสูจน์ได้ว่าเป็นตัวระบุที่ถูกต้องโดย:

• ค้นหาในรายการคำหลัก java (คำใบ้: คุณจะไม่พบที่นั่น!) หรือเพียงแค่
• โดยใช้เป็นตัวระบุและสังเกตว่าไม่มีข้อผิดพลาดเวลาคอมไพล์เกิดขึ้น

ตามที่คำตอบอื่น ๆ ระบุ

mainเป็นตัวระบุ Java ที่ถูกต้องเช่นเดียวกับjava1234.

ผมคิดว่าทำให้เกิดความสับสนมาจากความจริงที่ว่าmain(String[])วิธีการที่มักจะใช้เป็นจุดเริ่มต้นโดย JVM 1 อย่างไรก็ตามนั่นไม่ได้หมายความว่าโทเค็นmainนั้นไม่สามารถใช้เป็นตัวระบุ²ได้

ข้อกำหนดกล่าวไว้อย่างนั้นและการประกาศต่อไปนี้ก็ใช้ได้เช่นกัน:

• ฟิลด์:

  private int main;
  

• ตัวแปรท้องถิ่น:

  String main = "";
  

• วิธีการ:

  private void main() { ... }
  

• คลาส (แม้ว่าจะไม่สนับสนุนชื่อคลาสที่ขึ้นต้นด้วยตัวพิมพ์เล็ก):

  public class main { ... }
  

• บรรจุภัณฑ์:

  package main;
  

^{1: ตามที่ระบุไว้ในความคิดเห็นข้อกำหนดของ JVM นั้นไม่ได้กำหนดให้วิธีการใดเป็นจุดเริ่มต้น แต่javaเครื่องมือที่ใช้กันอย่างแพร่หลายมักใช้วิธีการดังกล่าวเป็นจุดเริ่มต้น
2: โดยทั่วไปฉันจะหลีกเลี่ยงการสร้างวิธีหลักอื่นที่ไม่ใช่main(String[]).}

สิ่งนี้รวบรวมได้ดีบน 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);
    }
}

... และเมื่อดำเนินการสร้างผลลัพธ์:

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

ฉันทุ่มทุกอย่างที่ทำได้และดูเหมือนว่าจะได้ผล ฉันจะบอกว่า main เป็นตัวระบุที่ถูกต้อง

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

วิธีmainไม่สามารถนำมาใช้เป็นตัวบ่งชี้ในขณะที่มันถูกใช้เป็นตัวบ่งชี้ที่จะประกาศวิธีการ "หลัก"?

สำหรับสำนวนคลาสสิกดังกล่าว:

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

main ไม่ใช่คีย์เวิร์ดและอาจไม่เป็นคีย์เวิร์ดใน Java เนื่องจากเหตุผลด้านความเข้ากันได้ย้อนยุคที่ชัดเจน

เกี่ยวกับคำถามเป็นmainตัวระบุที่ดีหรือไม่?

อันดับแรก: ถูกต้องสำหรับคอมไพเลอร์ไม่ได้หมายความว่าจะดีเสมอไป
ตัวอย่างเช่นไฟล์java1234ตัวเลือกที่เสนอเป็นตัวระบุที่ถูกต้อง แต่ควรหลีกเลี่ยงจริงๆ

mainมีความหมายโดยเฉพาะอย่างยิ่งและสำคัญมาก: ใช้เป็นวิธีจุดเริ่มต้นของคลาสและไหที่ดำเนินการโดยjavaบรรทัดคำสั่ง
การใช้mainชื่อเมธอดที่ไม่เติมเต็มเกณฑ์ที่จะใช้โดยjavaบรรทัดคำสั่งจะทำให้เข้าใจผิดในขณะที่ใช้เป็นชื่อตัวแปรหรือชื่อคลาสอาจมีเหตุผล
ตัวอย่างเช่นการกำหนดคลาสที่แสดงถึงจุดเริ่มต้นของแอ็พพลิเคชันเนื่องจากMainคลาสของแอ็พพลิเคชันเป็นที่ยอมรับและใช้เป็นชื่อตัวแปรเช่น:

public class Main {

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

}

โดยทั่วไปใน Java อักขระหลายตัวหรือ "คำ" ถือเป็นตัวระบุที่ถูกต้องสำหรับคอมไพเลอร์ แต่ไม่แนะนำอย่างยิ่งที่จะใช้ในรหัสไคลเอ็นต์ (แต่โค้ดที่สร้างขึ้นอาจทำเช่นนั้น: คลาสที่ซ้อนกันเป็นต้น) ซึ่งไม่สามารถอ่านได้และ / หรือทำให้เข้าใจผิดจริงๆ

ตัวอย่างเช่นสิ่งนี้อาจใช้ได้สำหรับคอมไพเลอร์:

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

แต่เราไม่ต้องการ:

• เพื่อตั้งชื่อObjectคลาสของเราตามที่กำหนดไว้ในjava.lang(1)
• เพื่อตั้งชื่อเมธอดmain()หากไม่เติมเต็มเกณฑ์ที่จะใช้โดยjavaบรรทัดคำสั่ง (2)
• เพื่อโอเวอร์โหลดObject.toString()วิธีการ (3)
• การตั้งชื่อตัวแปรของเราด้วย_, $หรือน่าแปลกใจ / ตัวอักษรใด unmeaningful ที่ไปกับการตั้งชื่อที่ใช้ร่วมกัน (4)

เป็นตัวระบุที่ถูกต้องหรือไม่? ใช่.

เป็นตัวระบุที่ดีหรือไม่? ไม่ใช่ถ้าคุณใช้มันเพื่อสิ่งอื่นนอกเหนือจากวิธีการที่เริ่มต้นเมื่อเปิดตัว JVM

มีตัวระบุอื่นที่ถูกต้องอยู่ในรายการหรือไม่ ใช่.

คำแนะนำในการทดสอบบอกว่าให้เลือกคำตอบที่ดีที่สุดหรือไม่?

mainถูกต้องสมบูรณ์เพราะจากเอกสาร :

1. เป็น "ลำดับของตัวอักษร Java และตัวเลข Java ซึ่งตัวแรกคือตัวอักษร Java"
2. ไม่ใช่ก คำหลัก
3. ไม่ใช่ลิเทอรัลบูลีนเช่น "จริง" หรือ "เท็จ"
4. ไม่ใช่ตัวอักษรว่างเปล่า

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

ครูคนนั้นทำผิดพลาดเล็กน้อยโดยถือว่าmainไม่ใช่ตัวระบุที่ถูกต้องหรือเพียงแค่ใช้สำนวนคำถามผิด เขาอาจหมายถึงการพูดว่า "ตัวระบุที่ดี"
แต่การเพิกเฉยต่อข้อโต้แย้งของบุตรชายของคุณและด้วยเหตุนี้จึงทำให้ไม่สนใจวิธีการทางวิทยาศาสตร์ของเขาในการตรวจสอบวรรณกรรมที่เกี่ยวข้อง (ข้อกำหนด Java) และทำการทดลอง (เขียนโปรแกรมตัวอย่าง) เป็นสิ่งที่ตรงกันข้ามกับสิ่งที่ครูควรทำ

ทั้งสองอย่างmainและjava123เป็นตัวระบุที่ถูกต้อง main ไม่ใช่คีย์เวิร์ดที่สงวนไว้ดังนั้นจึงเป็นที่ยอมรับอย่างสมบูรณ์ในการใช้งานเท่าที่การทดสอบดำเนินไปคุณควรได้คะแนนหรือครึ่งหนึ่งเป็นอย่างน้อย

1. ควรเป็นคำเดียว นั่นคือไม่อนุญาตให้เว้นวรรค

   ตัวอย่าง: ราคามะม่วงถูกต้อง แต่ราคามะม่วงไม่ถูกต้อง

2. ควรขึ้นต้นด้วยตัวอักษร (ตัวอักษร) หรือขีดล่างหรือสัญลักษณ์ $

   ตัวอย่าง: price, _price และ $ price เป็นตัวระบุที่ถูกต้อง

3. ไม่ควรเป็นคีย์เวิร์ดของ Java เนื่องจากคีย์เวิร์ดมีความหมายพิเศษต่อคอมไพเลอร์

   ตัวอย่าง: คลาสหรือโมฆะเป็นต้น

4. ไม่ควรขึ้นต้นด้วยเลขโดด แต่หลักสามารถอยู่ตรงกลางหรือท้าย

   ตัวอย่าง: 5mangoescost ไม่ถูกต้องและ mango5cost และ mangocost5 ใช้ได้

5. ความยาวของตัวระบุใน Java สามารถมีอักขระได้ 65,535 ตัวและทั้งหมดมีความสำคัญ ตัวระบุเป็นกรณี ๆ ไป นั่นคือมะม่วงและมะม่วงจะได้รับการปฏิบัติที่แตกต่างกัน สามารถประกอบด้วยตัวอักษรตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กหรือส่วนผสม

IDENTIFIER : เป็นชื่อคลาสชื่อเมธอดชื่อตัวแปร ...

เนื่องจาก main ไม่ใช่คำสงวนและตามคำอธิบายด้านบนสำหรับการกำหนดตัวระบุmain คือตัวระบุที่ถูกต้องและjava1234ด้วยตัวเลือกที่เหลือไม่ถูกต้องเนื่องจากคำอธิบายข้างต้น