Your First Java Program

What Is It?

What Is a Java Program?

A Java program is a collection of instructions written in the Java programming language that the computer can execute. Every Java program consists of at least one class, and every standalone program must have a special method called main that serves as the entry point -- the place where execution begins.

Unlike scripting languages like Python where you can write a single line of code and run it, Java requires a specific structure. Your code must live inside a class, and the executable code must be inside methods. This structure may feel verbose at first, but it enforces organization and makes large programs manageable.

In this chapter, you will write your first Java program, understand every keyword in the public static void main(String[] args) signature, learn how to print output, add comments, follow naming conventions, and understand what happens when your code is compiled and run.

Why Does It Matter?

Why Is Understanding Program Structure Important?

Every Java program you ever write will follow the same basic structure. Understanding it thoroughly now prevents confusion later and builds a solid foundation for everything that follows.

1. The main Method Is Where Everything Starts

When you run a Java program, the JVM looks for the main method with a very specific signature. If this method is missing, has the wrong signature, or is misspelled, your program will not run. Understanding why each keyword (public, static, void) is required helps you understand Java's design philosophy.

2. Output Is How Programs Communicate

System.out.println is the most basic way for a program to display results. You will use it in every chapter, every exercise, and every debugging session. Understanding the difference between println, print, and printf gives you control over how your output looks.

3. Comments Make Code Maintainable

Professional code always includes comments. In placement coding rounds, well-commented solutions demonstrate clarity of thought. In team environments, comments help other developers (and your future self) understand your logic.

4. Naming Conventions Are Non-Negotiable

Java has strict naming conventions that the entire industry follows. Using camelCase for variables, PascalCase for classes, and UPPER_SNAKE_CASE for constants is not optional -- it is expected in interviews, code reviews, and professional codebases.

Detailed Explanation

Detailed Explanation

1. Anatomy of a Java Program

Let us dissect the simplest possible Java program line by line:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Line 1: public class HelloWorld {

• public -- This is an access modifier that makes the class accessible from anywhere. Every Java source file can have at most one public class, and the file name must match this class name.
• class -- This keyword declares a class. In Java, all code must be inside a class. A class is a blueprint that groups related data and methods.
• HelloWorld -- This is the class name. It must match the file name exactly (HelloWorld.java). By convention, class names use PascalCase (each word capitalized).
• { -- The opening curly brace marks the beginning of the class body.

Line 2: public static void main(String[] args) {

This is the main method signature. Every keyword here is required and has a specific purpose:

• public -- The method must be accessible by the JVM from outside the class. If you make it private, the JVM cannot call it.
• static -- The method belongs to the class itself, not to an instance (object) of the class. The JVM calls main without creating an object, so it must be static.
• void -- The method does not return any value. The main method performs actions but does not return a result to the JVM.
• main -- This is the method name. The JVM specifically looks for a method named main. You cannot change this name.
• String[] args -- This is a parameter: an array of Strings that receives command-line arguments. Even if you do not use command-line arguments, this parameter must be present. You can also write it as String args[] or String... args.

Line 3: System.out.println("Hello, World!");

• System -- A built-in class in the java.lang package that provides access to system-level resources.
• out -- A static field of the System class, representing the standard output stream (typically the console/terminal).
• println -- A method that prints the given text followed by a newline character. "println" stands for "print line."
• "Hello, World!" -- A String literal enclosed in double quotes.
• ; -- Every statement in Java must end with a semicolon. This is required, not optional.

Line 4 and 5: Closing Braces

The first } closes the main method. The second } closes the class. Every opening brace must have a matching closing brace.

2. Printing Output: println vs print vs printf

Java provides three primary methods for console output:

System.out.println()

Prints the argument followed by a newline character. The cursor moves to the next line after printing. This is the most commonly used output method.

System.out.print()

Prints the argument without a newline. The cursor stays on the same line. Useful when you want multiple outputs on the same line.

System.out.printf()

Prints formatted output using format specifiers, similar to C's printf. Common format specifiers:

3. Comments in Java

Comments are text that the compiler ignores. They exist solely for humans reading the code.

Single-Line Comments

Start with //. Everything after // on that line is ignored by the compiler.

// This is a single-line comment
int age = 20; // This comment is after code

Multi-Line Comments

Start with /* and end with */. Can span multiple lines.

/* This is a multi-line comment.
   It can span several lines.
   Useful for longer explanations. */

Javadoc Comments

Start with /** and end with */. Used to generate API documentation with the javadoc tool.

/**
 * Calculates the area of a rectangle.
 * @param length the length of the rectangle
 * @param width the width of the rectangle
 * @return the calculated area
 */

4. Java Naming Conventions

Java has well-established naming conventions that every professional developer follows:

5. Escape Sequences

Escape sequences allow you to include special characters in strings that cannot be typed directly:

6. The Compilation Process

When you compile and run a Java program, the following steps happen:

1. Source Code: You write HelloWorld.java containing human-readable Java code
2. Compilation: javac HelloWorld.java invokes the Java compiler, which: parses the source code, checks for syntax and type errors, and generates HelloWorld.class containing bytecode
3. Loading: java HelloWorld starts the JVM, which uses the Class Loader to load HelloWorld.class into memory
4. Verification: The bytecode verifier checks the code for safety and correctness
5. Execution: The execution engine (interpreter + JIT compiler) runs the bytecode, starting from the main method

7. Command-Line Arguments

The String[] args parameter in the main method receives arguments passed from the command line. When you run java HelloWorld Aarav 20, the args array contains ["Aarav", "20"]. This allows your program to accept input without interactive prompts.

Code Examples

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

public class PrintDemo {
    public static void main(String[] args) {
        // println - prints with newline
        System.out.println("Line 1");
        System.out.println("Line 2");

        // print - no newline, stays on same line
        System.out.print("Hello ");
        System.out.print("World");
        System.out.println();  // just a newline

        // printf - formatted output
        String name = "Aarav";
        int age = 20;
        double gpa = 8.75;
        System.out.printf("Name: %s, Age: %d, GPA: %.2f%n", name, age, gpa);

        // printf with width formatting
        System.out.printf("%-10s %5d %8.2f%n", "Priya", 21, 9.10);
        System.out.printf("%-10s %5d %8.2f%n", "Rohan", 19, 7.85);
    }
}

/**
 * StudentGreeter - Demonstrates all three comment types in Java.
 * This Javadoc comment can be used to generate documentation.
 * @author Priya
 * @version 1.0
 */
public class StudentGreeter {

    // This is a single-line comment
    // The main method is the program's entry point
    public static void main(String[] args) {

        /* Multi-line comment:
           We declare a variable and use it
           to create a personalized greeting. */
        String studentName = "Vikram";
        int semester = 4;

        // Print the greeting
        System.out.println("Welcome, " + studentName + "!");
        System.out.println("Semester: " + semester);

        // TODO: Add more student details later
    }
}

public class Concatenation {
    public static void main(String[] args) {
        String firstName = "Ananya";
        String lastName = "Sharma";
        int age = 19;
        double percentage = 87.5;

        // String concatenation with +
        System.out.println("Name: " + firstName + " " + lastName);
        System.out.println("Age: " + age);
        System.out.println("Score: " + percentage + "%");

        // Tricky: numbers and strings
        System.out.println(10 + 20 + " students");      // 30 students (math first)
        System.out.println("Roll: " + 10 + 20);          // Roll: 1020 (concatenation)
        System.out.println("Sum: " + (10 + 20));          // Sum: 30 (parentheses force math)
    }
}

public class EscapeDemo {
    public static void main(String[] args) {
        // Newline
        System.out.println("Line 1\nLine 2\nLine 3");

        // Tab (useful for alignment)
        System.out.println("Name\tAge\tCity");
        System.out.println("Aarav\t20\tDelhi");
        System.out.println("Neha\t19\tMumbai");

        // Quotes inside strings
        System.out.println("He said, \"Java is great!\"");

        // Backslash
        System.out.println("File path: C:\\Users\\Aarav\\code");

        // Single quote (not strictly necessary in strings, but valid)
        System.out.println("It\'s a sunny day");
    }
}

public class CommandArgs {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);

        if (args.length > 0) {
            System.out.println("First argument: " + args[0]);
        }

        if (args.length > 1) {
            System.out.println("Second argument: " + args[1]);
        }

        // Print all arguments
        System.out.println("\nAll arguments:");
        for (int i = 0; i < args.length; i++) {
            System.out.println("  args[" + i + "] = " + args[i]);
        }
    }
}

// Run: java CommandArgs Aarav 20 Delhi
// Output: First argument: Aarav, Second: 20, etc.

// File: GreetingApp.java
// Only ONE class can be public, and it must match the file name

public class GreetingApp {
    public static void main(String[] args) {
        String message = MessageHelper.getGreeting("Rohan");
        System.out.println(message);
        System.out.println("Program executed successfully.");
    }
}

// This class is NOT public (default access)
// It can be in the same file as GreetingApp
class MessageHelper {
    static String getGreeting(String name) {
        return "Hello, " + name + "! Welcome to Java programming.";
    }
}

public class NamingConventions {
    // Constant: UPPER_SNAKE_CASE
    static final double PI_VALUE = 3.14159;
    static final int MAX_STUDENTS = 60;

    public static void main(String[] args) {
        // Variable: camelCase
        String studentName = "Neha";
        int rollNumber = 42;
        double semesterGpa = 8.9;
        boolean isPlaced = true;

        // Method call: camelCase
        displayStudentInfo(studentName, rollNumber, semesterGpa, isPlaced);
    }

    // Method: camelCase
    static void displayStudentInfo(String name, int roll, double gpa, boolean placed) {
        System.out.println("=== Student Info ===");
        System.out.println("Name: " + name);
        System.out.println("Roll: " + roll);
        System.out.println("GPA: " + gpa);
        System.out.println("Placed: " + placed);
        System.out.println("Max Students: " + MAX_STUDENTS);
    }
}
// Class name: PascalCase (NamingConventions)
// Package names: all lowercase (com.example.app)

Common Mistakes

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello")
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

public class Test {
    public void main(String[] args) {  // Missing 'static'
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.printLn("Hello");  // Wrong: capital L
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");  // Correct: lowercase l, lowercase n
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Score: " + 10 + 20);
        // Expected: Score: 30
        // Actual: Score: 1020
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Score: " + (10 + 20));  // Score: 30
    }
}

public class Test {
    public static void main(String[] args)
        System.out.println("Hello");
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println('Hello World');  // Single quotes!
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World");  // Double quotes for strings
        System.out.println('H');             // Single quotes for single characters only
    }
}

Summary