Syntax for command line arguments in Java - Step-by-Step Execution

Concept Flow - Syntax for command line arguments

Start Program

↓

Read args array

↓

Check args length

Yes No↓

Use args

↓

Process args

↓

End Program

The program starts and reads the command line arguments from the args array, checks if arguments exist, then processes them or handles no arguments.

Execution Sample

Java

public class Main {
  public static void main(String[] args) {
    if (args.length > 0) {
      System.out.println("First arg: " + args[0]);
    } else {
      System.out.println("No arguments passed.");
    }
  }
}

Prints the first command line argument passed to the program, or a message if no arguments are passed.

Execution Table

Step	Action	args array content	Output	Notes
1	Program starts	args = ["hello", "world"]		args array filled with command line inputs
2	Access args[0]	["hello", "world"]		First argument is "hello"
3	Print args[0]	["hello", "world"]	First arg: hello	Output to console
4	Program ends	["hello", "world"]		Program finishes execution

💡 Program ends after printing the first argument.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
args	empty	["hello", "world"]	["hello", "world"]	["hello", "world"]	["hello", "world"]

Key Moments - 2 Insights

Why do we use args[0] to get the first command line argument?

Because args is an array where the first element (index 0) holds the first argument passed. See execution_table step 2.

What happens if no command line arguments are passed?

The args array is empty, so accessing args[0] causes an error. The program should check args.length before accessing. See concept_flow decision.

Visual Quiz - 3 Questions

Look at the execution_table, what is printed at step 3?

A First arg: hello

B First arg: world

C First arg: args[0]

D No output

💡 Hint

Check the Output column in execution_table row for step 3.

At which step does the program read the command line arguments?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the Action and args array content at each step in execution_table.

If no arguments are passed, what should the program do to avoid errors?

A Ignore args array

B Access args[0] anyway

C Check if args.length > 0 before accessing

D Use args[1] instead

💡 Hint

Refer to concept_flow where the program checks args length before using args.

Concept Snapshot

Java command line arguments are passed as a String array named args to main.
Access arguments by index: args[0], args[1], etc.
Always check args.length before accessing to avoid errors.
Example: public static void main(String[] args) { if (args.length > 0) { System.out.println(args[0]); } else { System.out.println("No arguments passed."); } }

Full Transcript

In Java, command line arguments are given to the main method as a String array called args. The program starts and the args array contains the arguments typed after the program name. We access the first argument with args[0]. If no arguments are passed, args is empty, so we must check args.length before accessing to avoid errors. The example program prints the first argument or a message if none are passed. The execution steps show the program starting, reading args, printing the first argument, then ending.

Practice

1. What is the correct way to declare the main method to accept command line arguments in Java?

easy

A. public void main(String args)

B. public static void main(String[] args)

C. static void main(String args[])

D. public static int main(String[] args)

Solution

1. Step 1: Understand main method signature

   The main method must be public, static, return void, and accept a String array parameter.

2. Step 2: Check each option

   public static void main(String[] args) matches the correct signature exactly. Others either miss static, have wrong return type, or wrong parameter type.

3. Final Answer:

   public static void main(String[] args) -> Option B

4. Quick Check:

   Main method signature = public static void main(String[] args) [OK]

Hint: Main method always: public static void main(String[] args) [OK]

Common Mistakes:

• Omitting static keyword
• Using wrong parameter type
• Changing return type from void

2. Which of the following is the correct way to access the first command line argument inside the main method?

easy

A. args[0]

B. args.first()

C. args.get(0)

D. args(0)

Solution

1. Step 1: Recall how arrays are accessed in Java

   Java arrays use square brackets [] with zero-based indexing to access elements.

2. Step 2: Evaluate options

   Only args[0] uses correct syntax. args(0) and args.get(0) are invalid for arrays, and args.first() is not a method for arrays.

3. Final Answer:

   args[0] -> Option A

4. Quick Check:

   Array access uses square brackets = args[0] [OK]

Hint: Use square brackets to access array elements: args[0] [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Trying to call methods on array
• Confusing with List syntax

3. What will be the output of the following Java program if run with command line arguments: java Program Hello World?

public class Program {
    public static void main(String[] args) {
        System.out.println(args.length);
        System.out.println(args[0]);
        System.out.println(args[1]);
    }
}

medium

A. 2
Hello
World

B. 3
Hello
World

C. 2
World
Hello

D. 3
World
Hello

Solution

1. Step 1: Count command line arguments

   Arguments are "Hello" and "World", so args.length is 2.

2. Step 2: Check printed values

   args[0] is "Hello", args[1] is "World". So output lines are 2, Hello, World.

3. Final Answer:

   2 Hello World -> Option A

4. Quick Check:

   args.length=2, args[0]=Hello, args[1]=World [OK]

Hint: args.length counts arguments; args[0] is first argument [OK]

Common Mistakes:

• Counting program name as argument
• Swapping args[0] and args[1]
• Assuming args.length includes program name

4. Identify the error in this Java program that tries to print all command line arguments:

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

medium

A. System.out.println should use args(i) instead of args[i]

B. args should be declared as int[] not String[]

C. Loop starts at 1 and uses <= causing ArrayIndexOutOfBoundsException

D. main method must return int, not void

Solution

1. Step 1: Analyze loop indexing

   The loop starts at i=1 and runs while i <= args.length. Array indices go from 0 to args.length-1.

2. Step 2: Identify error cause

   Accessing args[args.length] causes ArrayIndexOutOfBoundsException. Also, skipping args[0] misses first argument.

3. Final Answer:

   Loop starts at 1 and uses <= causing ArrayIndexOutOfBoundsException -> Option C

4. Quick Check:

   Array indices 0 to length-1, loop must use i=0 to i<length [OK]

Hint: Loop from 0 to args.length-1 to avoid index errors [OK]

Common Mistakes:

• Starting loop at 1 instead of 0
• Using <= instead of < in loop condition
• Using parentheses instead of brackets for array access

5. You want to write a Java program that sums two integers passed as command line arguments and prints the result. Which code snippet correctly parses and sums the arguments?

hard

A. int sum = Integer.parseInt(args[0]) + args[1].parseInt(); System.out.println(sum);

B. int sum = args[0] + args[1]; System.out.println(sum);

C. int sum = Integer.valueOf(args[0]) + args[1]; System.out.println(sum);

D. int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]); System.out.println(sum);

Solution

1. Step 1: Convert String arguments to integers

   Use Integer.parseInt() to convert each String argument to int.

2. Step 2: Sum the parsed integers and print

   Sum the two parsed ints and print the result using System.out.println.

3. Final Answer:

   int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]); System.out.println(sum); -> Option D

4. Quick Check:

   Parse strings to int with Integer.parseInt() before adding [OK]

Hint: Parse args with Integer.parseInt() before arithmetic [OK]

Common Mistakes:

• Adding strings directly without parsing
• Using wrong method to parse integers
• Calling parseInt() on string variable incorrectly