“ String args []” คืออะไร? พารามิเตอร์ในวิธีการหลัก Java

ฉันเพิ่งเริ่มเขียนโปรแกรมใน Java รหัส Java ต่อไปนี้หมายความว่าอย่างไร

public static void main(String[] args)

• คือString[] argsอะไร

• คุณจะใช้สิ่งเหล่านี้เมื่อargsใด

รหัสที่มาและ / หรือตัวอย่างเป็นที่ต้องการมากกว่าคำอธิบายที่เป็นนามธรรม

ใน Java argsมีอาร์กิวเมนต์บรรทัดคำสั่งที่ให้มาเป็นอาร์เรย์Stringวัตถุ

ในคำอื่น ๆ ถ้าคุณเรียกใช้โปรแกรมของคุณเป็นjava MyProgram one twoแล้วจะมีargs["one", "two"]

หากคุณต้องการส่งออกเนื้อหาของargsคุณก็สามารถวนรอบพวกเขาเช่นนี้ ...

public class ArgumentExample {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

สิ่งเหล่านี้มีไว้สำหรับอาร์กิวเมนต์บรรทัดคำสั่งใน Java

กล่าวอีกนัยหนึ่งถ้าคุณเรียกใช้

java MyProgram หนึ่งสอง

จากนั้นargsมี:

[ "หนึ่งสอง" ]

public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}

เหตุผลนี้คือการกำหนดค่าแอปพลิเคชันของคุณให้เรียกใช้วิธีการเฉพาะหรือให้ข้อมูลบางส่วนที่ต้องการ

ถ้าคุณยังใหม่กับ Java ผมขอแนะนำให้อ่านผ่านเว็บไซต์อย่างเป็นทางการของออราเคิลJava ^TMสอน

argsมีอาร์กิวเมนต์บรรทัดรับคำสั่งที่ส่งไปยังโปรแกรม Java เมื่อมีการเรียกใช้ ตัวอย่างเช่นถ้าฉันเรียกใช้โปรแกรมเช่น:

$ java MyProg -f file.txt

จากนั้นargsจะมีอาร์เรย์สตริงและ"-f""file.txt"

คำตอบต่อไปนี้มาจากความเข้าใจและการทดสอบของฉัน

String [] args คืออะไร

ตอบ ->

String [] -> ดังที่เราทราบว่านี่เป็นสตริงชุดอักขระธรรมดา

args -> เป็นชื่อของอาร์เรย์ที่สามารถเป็นอะไรก็ได้ (เช่น a, ar, อาร์กิวเมนต์, param, พารามิเตอร์) ไม่มีปัญหากับคอมไพเลอร์ & ดำเนินการ & ฉันทดสอบเช่นกัน

เช่น
1) โมฆะคงที่สาธารณะหลัก (String [] อาร์กิวเมนต์)

2) โมฆะสาธารณะคงที่หลัก (พารามิเตอร์ String [])

เมื่อไหร่ที่คุณจะใช้ args เหล่านี้?

Ans->

ฟังก์ชั่นหลักได้รับการออกแบบอย่างชาญฉลาดโดยนักพัฒนา การคิดที่แท้จริงนั้นลึกซึ้งมาก ซึ่งได้รับการพัฒนาโดยทั่วไปภายใต้การพิจารณาของ C & C ++ ตามอาร์กิวเมนต์บรรทัดคำสั่ง แต่ปัจจุบันไม่มีใครใช้มันมากขึ้น

สิ่งที่ 1 -ผู้ใช้สามารถป้อนข้อมูลประเภทใดก็ได้จากบรรทัดคำสั่งสามารถเป็น Number หรือ String และจำเป็นต้องยอมรับโดยคอมไพเลอร์ประเภทข้อมูลที่เราควรใช้? ดูสิ่งที่ 2

Thing 2- String คือประเภทข้อมูลที่รองรับประเภทข้อมูลดั้งเดิมทั้งหมดเช่น int, long, float, double, byte, shot, char ใน Java คุณสามารถแยกวิเคราะห์ได้ง่ายในประเภทข้อมูลดั้งเดิม

เช่นโปรแกรมต่อไปนี้ได้รับการคอมไพล์ & ดำเนินการ & ฉันทดสอบเช่นกัน

หากอินพุตคือ -> 1 1

// one class needs to have a main() method
public class HelloWorld
{
  // arguments are passed using the text field below this editor
  public static void main(String[] parameter)
  {    
System.out.println(parameter[0] + parameter[1]); // Output is 11

//Comment out below code in case of String
    System.out.println(Integer.parseInt(parameter[0]) + Integer.parseInt(parameter[1])); //Output is 2
    System.out.println(Float.parseFloat(parameter[0]) + Float.parseFloat(parameter[1])); //Output is 2.0    
    System.out.println(Long.parseLong(parameter[0]) + Long.parseLong(parameter[1])); //Output is 2    
    System.out.println(Double.parseDouble(parameter[0]) + Double.parseDouble(parameter[1])); //Output is 2.0    

  }
}

แม้สรรพสินค้า OP เป็นเพียงการพูดคุยเกี่ยวกับฉันต้องการให้เป็นตัวอย่างที่สมบูรณ์ของString[] argspublic static void main(String[] args)

Public: เป็นตัวดัดแปลงการเข้าถึงซึ่งกำหนดว่าใครสามารถเข้าถึงวิธีนี้ได้ สาธารณะหมายความว่าวิธีนี้จะสามารถเข้าถึงได้โดยชั้นเรียนใด ๆ (หากชั้นเรียนอื่นสามารถเข้าถึงชั้นนี้ได้)

Static: เป็นคำหลักที่ระบุสิ่งที่เกี่ยวข้องกับชั้นเรียน ซึ่งหมายความว่าวิธีการหรือตัวแปรที่กำหนดไม่เกี่ยวข้องกับอินสแตนซ์ แต่เกี่ยวข้องกับคลาส สามารถเข้าถึงได้โดยไม่ต้องสร้างอินสแตนซ์ของ Class

Void: ใช้เพื่อกำหนด Return Type ของวิธีการ มันกำหนดสิ่งที่วิธีการที่จะกลับมา Void หมายถึงวิธีการจะไม่ส่งคืนค่าใด ๆ

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

String[] args : เป็นพารามิเตอร์ของวิธีหลัก

หากคุณค้นหาซอร์สโค้ด JDK (jdk-src \ j2se \ src \ share \ bin \ java.c):

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                   "([Ljava/lang/String;)V");
...
{    /* Make sure the main method is public */
...
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
    message = "Main method not public.";
    messageDest = JNI_TRUE;
    goto leave;
...

คุณจะเห็นว่าวิธีการเริ่มต้นใน java จะต้องมีชื่อmainและต้องมีลายเซ็นเฉพาะpublic static void main(String[] args)

รหัสยังบอกเราpublic static void main(String[] args)ว่าไม่ได้รับการแก้ไขถ้าคุณเปลี่ยนรหัสใน (jdk-src \ j2se \ src \ share \ bin \ java.c) เป็นลายเซ็นอื่นมันจะทำงานได้ แต่การเปลี่ยนแปลงนี้จะทำให้คุณมีปัญหาอื่น ๆ เพราะรายละเอียดของจาวา

Offtopic: 7 ปีแล้วที่ OP ถามคำถามนี้ฉันเดาว่า OP สามารถตอบคำถามของเขาได้แล้ว

String [] args ยังเป็นวิธีที่คุณประกาศอาร์เรย์ของสตริงใน Java

ในลายเซ็นวิธีการนี้อาร์เรย์argsจะเต็มไปด้วยค่าเมื่อมีการเรียกใช้เมธอด (ตามตัวอย่างอื่น ๆ ที่นี่แสดง) เนื่องจากคุณกำลังเรียนรู้มันคุ้มค่าที่จะเข้าใจว่าargsอาเรย์นี้จะเหมือนกับว่าคุณสร้างด้วยตัวคุณเองในวิธีการเช่นเดียวกับในนี้:

public void foo() {
    String [] args = new String[2];
    args[0] = "hello";
    args[1] = "every";

    System.out.println("Output: " + args[0] + args[1]);

    // etc... the usage of 'args' here and in the main method is identical
}

ฉันจะเลิก

public static void main(String args[])

ในส่วน

"สาธารณะ"หมายถึงสามารถเรียก main () ได้จากทุกที่

"คงที่"หมายความว่า main () ไม่ได้อยู่ในวัตถุเฉพาะ

"void"หมายถึง main () ไม่ส่งคืนค่าใด ๆ

"main"เป็นชื่อของฟังก์ชั่น main () เป็นพิเศษเพราะเป็นจุดเริ่มต้นของโปรแกรม

"String []"หมายถึงอาร์เรย์ของ String

"args"เป็นชื่อของ String [] (ภายในส่วนของ main ()) "args" ไม่ใช่พิเศษ คุณสามารถตั้งชื่อมันเป็นอย่างอื่นและโปรแกรมก็จะทำงานเหมือนกัน

• String[] argsคือชุดของ Strings คั่นด้วยช่องว่างซึ่งสามารถพิมพ์ลงในโปรแกรมบนเทอร์มินัล หลายครั้งกว่าที่ผู้เริ่มต้นจะไม่ใช้ตัวแปรนี้ แต่จะมีในกรณีเสมอ

เมื่อคุณเสร็จรหัสของคุณคุณจะกลายเป็นไฟล์ที่มีนามสกุล. java ซึ่งสามารถเรียกใช้โดยการคลิกสองครั้ง แต่ยังรวมถึงคอนโซล (เทอร์มินัลบน mac, cmd.exe บน windows) ซึ่งช่วยให้ผู้ใช้ หลายสิ่ง. สิ่งหนึ่งคือพวกเขาสามารถเห็นข้อความคอนโซล (System.out.print หรือ System.out.println) ซึ่งพวกเขาไม่สามารถดูว่าพวกเขาคลิกสองครั้ง สิ่งอื่นที่พวกเขาสามารถทำได้คือระบุพารามิเตอร์ดังนั้นโดยปกติคุณจะใช้บรรทัด

java -jar MyCode.jar

หลังจากไปที่โฟลเดอร์ของโปรแกรมด้วย

cd C:My/Code/Location

บน windows หรือ

cd My/Code/Location

บน Mac (สังเกตเห็นว่า mac นั้นเป็น clunky น้อยกว่า) เพื่อเรียกใช้โค้ด แต่เพื่อระบุพารามิเตอร์ที่คุณจะใช้

java -jar MyCode.jar parameter1 parameter2

พารามิเตอร์เหล่านี้เก็บไว้ในอาร์เรย์ args ซึ่งคุณสามารถใช้ในโปรแกรมของคุณคือคุณต้องการอนุญาตให้ผู้ใช้ควบคุมพารามิเตอร์พิเศษเช่นไฟล์ที่จะใช้หรือจำนวนหน่วยความจำที่โปรแกรมสามารถใช้ หากคุณต้องการทราบวิธีการใช้อาเรย์คุณอาจพบหัวข้อในเว็บไซต์นี้หรือเพียงแค่ google โปรดทราบว่าสามารถใช้พารามิเตอร์จำนวนเท่าใดก็ได้

คำอธิบายในภาษาธรรมดาของคนธรรมดา

วิธีการหลักคาดว่าเราจะให้ข้อโต้แย้งบางอย่างเมื่อเรานำ JVM ของเราไปที่ชื่อชั้น นั่นหมายความว่าสมมติว่าชื่อไฟล์ของคุณคือ Try.java ตอนนี้เพื่อเรียกใช้งานในพรอมต์คำสั่งคุณเขียน "javac Try.java" เพื่อคอมไพล์แล้วตามด้วย "java Try" เพื่อดำเนินการ ทีนี้สมมุติว่าแทนที่จะเขียนแค่ "java Try" คุณเขียน "java Try 1" ที่นี่คุณได้ผ่านการโต้แย้ง "1" วิธีนี้จะใช้วิธีการหลักของคุณแม้ว่าคุณจะไม่ได้ใช้ในรหัสของคุณก็ตาม

หากคุณต้องการตรวจสอบว่าวิธีการหลักของคุณใช้อาร์กิวเมนต์ "1" จริงหรือไม่ เพียงแค่พิมพ์วิธีการหลักของคุณในรายการต่อไปนี้:

for(int i = 0; i < args.length; i++) {
        System.out.println("Argument is: "+args[i]);
    }

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

public static void main (String... args)

กล่าวอีกนัยหนึ่งmainวิธีการนั้นต้องยอมรับอาร์เรย์สตริง ( String args[]) หรือ varargs ( String... args) เป็นอาร์กิวเมนต์วิธี และไม่มีเวทมนต์ที่มีชื่อargsเช่นกัน คุณอาจเขียนargumentsหรือแม้กระทั่งfreddiefujiwaraตามที่แสดงใน e.gs ด้านล่าง:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

เมื่อคลาสจาวาดำเนินการจากคอนโซลวิธีหลักคือสิ่งที่เรียกว่า เพื่อให้สิ่งนี้เกิดขึ้นนิยามของวิธีการหลักนี้จะต้องเป็น

public static void main(String [])

ความจริงที่ว่าสตริงอาร์เรย์นี้เรียกว่า args เป็นแบบแผนมาตรฐาน แต่ไม่จำเป็นต้องเคร่งครัด คุณจะเติมอาร์เรย์นี้ที่บรรทัดคำสั่งเมื่อคุณเรียกใช้โปรแกรมของคุณ

java MyClass a b c

สิ่งเหล่านี้มักใช้เพื่อกำหนดตัวเลือกของโปรแกรมของคุณเช่นไฟล์ที่จะเขียนหรืออ่าน

ใน โมฆะสาธารณะคงที่หลัก (String args []) args เป็นอาร์เรย์ของอาร์กิวเมนต์บรรทัดคอนโซลที่มีชนิดข้อมูลเป็นสตริง ในอาร์เรย์นี้คุณสามารถจัดเก็บอาร์กิวเมนต์สตริงต่างๆโดยเรียกใช้ที่บรรทัดคำสั่งดังที่แสดงด้านล่าง: java myProgram Shaan Royal จากนั้น Shaan และ Royal จะถูกเก็บไว้ในอาร์เรย์ตาม ARG [0] = "Shaan"; หาเรื่อง [1] = "รอยัล"; คุณสามารถทำได้ด้วยตนเองภายในโปรแกรมเมื่อคุณไม่เรียกพวกเขาที่บรรทัดคำสั่ง

สไตล์ที่dataType[] arrayRefVarเป็นที่ต้องการ รูปแบบdataType arrayRefVar[]มาจากภาษา C / C ++ และถูกนำไปใช้ใน Java เพื่อรองรับโปรแกรมเมอร์ C / C ++

String[] argsพารามิเตอร์เป็นอาร์เรย์ของสตริงผ่านเป็นพารามิเตอร์เมื่อคุณใช้งานแอพลิเคชันของคุณผ่านบรรทัดคำสั่งในระบบปฏิบัติการ

ดังนั้นจินตนาการว่าคุณได้รวบรวมและบรรจุmyApp.jarแอปพลิเคชัน Java แล้ว คุณสามารถเรียกใช้แอปของคุณได้โดยดับเบิลคลิกในระบบปฏิบัติการ แต่คุณสามารถเรียกใช้แอพโดยใช้บรรทัดคำสั่งเช่น (ใน Linux เป็นต้น):

user@computer:~$ java -jar myApp.jar

เมื่อคุณโทรหาแอปพลิเคชันของคุณผ่านพารามิเตอร์บางอย่างเช่น:

user@computer:~$ java -jar myApp.jar update notify

java -jarคำสั่งจะผ่านสายของคุณupdateและnotifyที่คุณpublic static void main()วิธี

จากนั้นคุณสามารถทำสิ่งที่ชอบ:

System.out.println(args[0]); //Which will print 'update'
System.out.println(args[1]); //Which will print 'notify'

นอกจากความคิดเห็นก่อนหน้านี้ทั้งหมด

public static void main(String[] args) 

สามารถเขียนเป็น

 public static void main(String...arg)

หรือ

 public static void main(String...strings)