- javeine
- Для чего нужны аргументы командной строки String args[] в методе main?
- Lesson: A Closer Look at the «Hello World!» Application
- Source Code Comments
- The HelloWorldApp Class Definition
- The main Method
- What is String args[ ] in Java?
- Why is String. args[] in Java Needed?
- Example to Modify our Program to Print Content of String args[] in Java
- Conclusion
- Command-Line Arguments
- Echoing Command-Line Arguments
- Parsing Numeric Command-Line Arguments
javeine
Для чего нужны аргументы командной строки String args[] в методе main?
Метод main() указывает интерпретатору класс, с которого нужно начать выполнение программы. Однако в языке Java разрешено использовать несколько методов с названием main() даже в одном классе. Поэтому по-настоящему главный метод содержит аргументы командной строки (String[] args).
public class Testmain public static void main(String[] args)
if(args.length > 0) // если через консоль были введены аргументы
System.out.println(args[0]); // то вывести на консоль первый элемент из массива
else < // иначе —
Testmain obj = new Testmain(); //создать объект
obj.main(); // и использовать обычный метод с названием main()
>
>
public static void main() < // это обычный метод с названием main()
System.out.println(«it’s usual main method without String[] args!»);
>
>
.
В командной строке консоли после команды java Testmain было введено три аргумента: 1 2 3. В программе строка System.out.println(args[0]); выводит на консоль первый аргумент массива args[0], в данном случае выведено 1.
Если же аргументы не были указаны через консоль, то выполняется блок оператора else, в котором вызывается обычный метод, но тоже названный main().
Дополнительная информация:
args в методе main() — это название массива String[] и оно может быть другим.
public class Testmain2 public static void main(String[] lalala)
if(lalala.length > 0) // если через консоль были введены аргументы
System.out.println(lalala[0]); // то вывести на консоль первый элемент из массива
else < // иначе —
Testmain2 obj = new Testmain2(); // создать объект
obj.main(); // и использовать обычный метод с названием main()
>
>
public static void main() < // это обычный метод с названием main()
System.out.println(«it’s usual main method without String[] lalala!»);
>
>
.
Lesson: A Closer Look at the «Hello World!» Application
Now that you’ve seen the «Hello World!» application (and perhaps even compiled and run it), you might be wondering how it works. Here again is its code:
The «Hello World!» application consists of three primary components: source code comments, the HelloWorldApp class definition, and the main method. The following explanation will provide you with a basic understanding of the code, but the deeper implications will only become apparent after you’ve finished reading the rest of the tutorial.
Source Code Comments
/** * The HelloWorldApp class implements an application that * simply prints "Hello World!" to standard output. */ class HelloWorldApp < public static void main(String[] args) < System.out.println("Hello World!"); // Display the string. > > Comments are ignored by the compiler but are useful to other programmers. The Java programming language supports three kinds of comments:
/* text */ The compiler ignores everything from /* to */ . /** documentation */ This indicates a documentation comment (doc comment, for short). The compiler ignores this kind of comment, just like it ignores comments that use /* and */ . The javadoc tool uses doc comments when preparing automatically generated documentation. For more information on javadoc , see the Javadoc™ tool documentation . // text The compiler ignores everything from // to the end of the line.
The HelloWorldApp Class Definition
/** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp public static void main(String[] args) < System.out.println("Hello World!"); // Display the string. >> As shown above, the most basic form of a class definition is:
The keyword class begins the class definition for a class named name , and the code for each class appears between the opening and closing curly braces marked in bold above. Chapter 2 provides an overview of classes in general, and Chapter 4 discusses classes in detail. For now it is enough to know that every application begins with a class definition.
The main Method
/** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp < public static void main(String[] args) System.out.println("Hello World!"); //Display the string. > > In the Java programming language, every application must contain a main method whose signature is:
public static void main(String[] args)
The modifiers public and static can be written in either order ( public static or static public ), but the convention is to use public static as shown above. You can name the argument anything you want, but most programmers choose «args» or «argv».
The main method is similar to the main function in C and C++; it’s the entry point for your application and will subsequently invoke all the other methods required by your program.
The main method accepts a single argument: an array of elements of type String .
public static void main(String[] args)
This array is the mechanism through which the runtime system passes information to your application. For example:
Each string in the array is called a command-line argument. Command-line arguments let users affect the operation of the application without recompiling it. For example, a sorting program might allow the user to specify that the data be sorted in descending order with this command-line argument:
The «Hello World!» application ignores its command-line arguments, but you should be aware of the fact that such arguments do exist.
System.out.println("Hello World!"); uses the System class from the core library to print the «Hello World!» message to standard output. Portions of this library (also known as the «Application Programming Interface», or «API») will be discussed throughout the remainder of the tutorial.
What is String args[ ] in Java?
String args[] in java is an array of type java.lang.String class that stores java command line arguments. Here, the name of the String array is args (short form for arguments), however it is not necessary to name it args always, we can name it anything of our choice, but most of the programmers prefer to name it args.
We can write String args[] as String[] args as well, because both are valid way to declare String array in Java.
From Java 5 onwards, we can use variable arguments in main() method instead of String args[] . This means that the following declaration of main() method is also valid in Java : public static void main(String. args) , and we can access this variable argument as normal array in Java.
Why is String. args[] in Java Needed?
Varargs or Variable Arguments in Java was introduced as a language feature in J2SE 5.0. This feature allows the user to pass an arbitary number of values of the declared date type to the method as parameters (including no parameters) and these values will be available inside the method as an array. While in previous versions of Java, a method to take multiple values required the user to create an array and put those values into the array before invoking the method, but the new introduces varargs feature automates and hides this process.
The dots or periods( . ) are known as ELLIPSIS , which we usually use intentionally to omit a word, or a whole section from a text without altering its original meaning. The dots are used having no gap in between them.
The three periods( . ) indicate that the argument may be passed as an array or as a sequence of arguments. Therefore String… args is an array of parameters of type String, whereas String is a single parameter. A String[] will also fulfill the same purpose but the main point here is that String… args provides more readability to the user. It also provides an option that we can pass multiple arrays of String rather than a single one using String[] .
Example to Modify our Program to Print Content of String args[] in Java
When we run a Java program from command prompt, we can pass some input to our Java program. Those inputs are stored in this String args array. For example if we modify our program to print content of String args[] , as shown below:
The following Java Program demonstrates the working of String[] args in the main() method:
Compile the above program using the javac Test.java command and run the compiled Test file using the following command:
Explanation:
In the above example, we have passed three arguments separated by white space during execution using java command. If we want to combine multiple words, which has some white space in between, then we can enclose them in double quotes. If we run our program again with following command:
Conclusion
- string args[] in java is an array of type java.lang.String class that stores java command line arguments.
- Variable argument or varargs in Java allows us to write more flexible methods which can accept as many arguments as we need
- The three periods(. ) in String… args[] indicate that the argument may be passed as an array or as a sequence of arguments.
- (String… args) is an array of parameters of type String, whereas String[] is a single parameter. String[] can full fill the same purpose but just (String… args) provides more readability and easiness to use.
Command-Line Arguments
A Java application can accept any number of arguments from the command line. This allows the user to specify configuration information when the application is launched.
The user enters command-line arguments when invoking the application and specifies them after the name of the class to be run. For example, suppose a Java application called Sort sorts lines in a file. To sort the data in a file named friends.txt , a user would enter:
When an application is launched, the runtime system passes the command-line arguments to the application’s main method via an array of String s. In the previous example, the command-line arguments passed to the Sort application in an array that contains a single String : «friends.txt» .
Echoing Command-Line Arguments
The Echo example displays each of its command-line arguments on a line by itself:
The following example shows how a user might run Echo . User input is in italics.
java Echo Drink Hot Java Drink Hot Java
Note that the application displays each word Drink , Hot , and Java on a line by itself. This is because the space character separates command-line arguments. To have Drink , Hot , and Java interpreted as a single argument, the user would join them by enclosing them within quotation marks.
java Echo "Drink Hot Java" Drink Hot Java
Parsing Numeric Command-Line Arguments
If an application needs to support a numeric command-line argument, it must convert a String argument that represents a number, such as «34», to a numeric value. Here is a code snippet that converts a command-line argument to an int :
int firstArg; if (args.length > 0) < try < firstArg = Integer.parseInt(args[0]); >catch (NumberFormatException e) < System.err.println("Argument" + args[0] + " must be an integer."); System.exit(1); >> parseInt throws a NumberFormatException if the format of args[0] isn’t valid. All of the Number classes Integer , Float , Double , and so on have parseXXX methods that convert a String representing a number to an object of their type.