A Java program is usually written in a file ending with .java. Inside that file, we commonly have:

• Class (mandatory – Java code lives inside classes)
• main method (mandatory for a runnable program – entry point)
• Other methods (optional – for reusable tasks)

public class MyProgram {

    public static void main(String[] args) {
        // Program starts here
    }

    // Your own methods here
}

The biggest difference between Java and some other languages is that Java is very structured. Java forces you to put code inside classes so that large applications can be organized well.

A class is a blueprint or container that holds data (variables) and behavior (methods). Even if you don’t create objects now, you must understand that Java code is organized around classes.

Think of a class like a “toolbox”:

• The toolbox name is the class name.
• Tools inside are methods.
• Some tools can be used without creating a toolbox copy (static methods).
• Some tools require a toolbox object (non-static methods).

For now, focus on structure. In upcoming OOP lessons, we will go deep into classes and objects.

Java has a strict rule:

Correct:

// File name: HelloWorld.java
public class HelloWorld { }

Wrong:

// File name: Hello.java
public class HelloWorld { }

If you do it wrong, you’ll get this famous error: class HelloWorld is public, should be declared in a file named HelloWorld.java

You can have multiple classes in a single file, but only one can be public. As a beginner, keep it simple: one file = one public class.

The main() method is the starting point of a Java program. When you run a class using: java ClassName, JVM looks for a method with the exact signature:

public static void main(String[] args)

If JVM cannot find it, your program will not start. That’s why main is called “entry point.”

You can write other methods and call them from main. This is the common pattern: main is your “controller” that calls other methods to perform tasks.

Let’s break each word:

Example of passing arguments:

// Run like this:
java HelloWorld Karthik Chennai

// args[0] = "Karthik"
// args[1] = "Chennai"

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Name: " + args[0]);
        System.out.println("City: " + args[1]);
    }
}

A method is a reusable block of code that performs a specific task. Instead of writing the same logic again and again, we put it in a method and call it when needed.

General method structure:

accessModifier static/non-static returnType methodName(parameters) {
    // code
    return something; // only if returnType is not void
}

Example: a method to print a welcome message:

public static void welcome() {
    System.out.println("Welcome to Tamil Technicians Java Course!");
}

Now you can call this method from main:

public class Demo {
    public static void main(String[] args) {
        welcome();
    }

    public static void welcome() {
        System.out.println("Welcome to Tamil Technicians Java Course!");
    }
}

As a beginner, you will mostly write static methods first. Why? Because main is static, and static methods can be called easily without creating objects.

Static method (easy for beginners):

public class StaticExample {
    public static void main(String[] args) {
        sayHi(); // call directly
    }

    public static void sayHi() {
        System.out.println("Hi!");
    }
}

Non-static method (needs object):

public class NonStaticExample {
    public static void main(String[] args) {
        NonStaticExample obj = new NonStaticExample();
        obj.sayHi(); // call using object
    }

    public void sayHi() {
        System.out.println("Hi!");
    }
}

Methods can take inputs (parameters) and can return outputs (return values). This is how we build clean and reusable logic.

Method with parameters (input):

public static void greet(String name) {
    System.out.println("Hello, " + name);
}

Method with return value (output):

public static int add(int a, int b) {
    return a + b;
}

Using them inside main:

public class MethodDemo {
    public static void main(String[] args) {
        greet("Karthik");

        int result = add(10, 20);
        System.out.println("Sum = " + result);
    }

    public static void greet(String name) {
        System.out.println("Hello, " + name);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

Let’s build a small “bill calculator” style program using methods. This teaches: program structure + calling methods + parameters + return.

import java.util.Scanner;

public class BillCalculator {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter item price: ");
        double price = sc.nextDouble();

        System.out.print("Enter quantity: ");
        int qty = sc.nextInt();

        System.out.print("Enter GST percent (example 18): ");
        double gstPercent = sc.nextDouble();

        double subTotal = calculateSubTotal(price, qty);
        double gstAmount = calculateGST(subTotal, gstPercent);
        double total = subTotal + gstAmount;

        printBill(price, qty, subTotal, gstPercent, gstAmount, total);

        sc.close();
    }

    // Method 1: calculate subtotal
    public static double calculateSubTotal(double price, int qty) {
        return price * qty;
    }

    // Method 2: calculate GST amount
    public static double calculateGST(double subTotal, double gstPercent) {
        return subTotal * (gstPercent / 100.0);
    }

    // Method 3: print bill neatly
    public static void printBill(double price, int qty, double subTotal,
                                 double gstPercent, double gstAmount, double total) {
        System.out.println("\n------ BILL ------");
        System.out.println("Price   : " + price);
        System.out.println("Qty     : " + qty);
        System.out.println("SubTotal: " + subTotal);
        System.out.println("GST %   : " + gstPercent);
        System.out.println("GST Amt : " + gstAmount);
        System.out.println("Total   : " + total);
        System.out.println("------------------");
    }
}

Run this:

javac BillCalculator.java
java BillCalculator

Mistake 1: File name and public class name mismatch

Fix: public class BillCalculator must be in BillCalculator.java

Mistake 2: Calling non-static method from static main

Fix: either make method static or create an object.

// Wrong (calling non-static from main)
public void test(){ }

public static void main(String[] args){
    test(); // ❌
}

// Fix 1: make it static
public static void test(){ }

// Fix 2: create object
ClassName obj = new ClassName();
obj.test();

Mistake 3: Missing return in non-void method

Fix: If return type is int, you must return an int.

• Create WelcomeApp.java with main and a method welcome().
• Create a method square(int n) that returns n*n. Print output in main.
• Create a method isAdult(int age) that returns true/false.
• Create a small program using 3 methods: input, compute, print.
• Try passing command line args and print them.

// Starter practice:
public class Practice {
    public static void main(String[] args) {
        System.out.println("Square of 7 = " + square(7));
        System.out.println("Adult? " + isAdult(18));
    }

    public static int square(int n) {
        return n * n;
    }

    public static boolean isAdult(int age) {
        return age >= 18;
    }
}

• Java Course Index
• Install JDK + Setup Editors
• JDK vs JRE vs JVM
• Next: Variables & Data Types