Java First Steps

Source, compile, run: your first program

Goal You can say what source code, compile and run mean, and you can write, compile and run a program that prints text.

A program is a list of instructions for a computer. You write the list as text in a file. That text is called source code. A Java source file has a name that ends in .java.

A computer cannot follow Java text directly. A program called the compiler translates it first. The compiler for Java is javac. It reads Main.java and writes a new file, Main.class, which holds bytecode. Bytecode is a compact list of instructions made for Java's own virtual machine. The translating step is called compiling.

Then the Java Virtual Machine, or JVM, reads the bytecode and carries out the instructions. Starting it is called running the program. You start it with the command java.

So there are always two steps. You type them in a terminal, which is a window for typing commands (see Set up your computer):

javac Main.java
java Main

The first command compiles. The second one runs. Notice that the second command is just Main, with no .java and no .class, because you give the name of a class, not of a file. Newer JDKs (version 11 and later) also accept java Main.java, which does both steps at once. This guide uses two steps so you can see each of them.

If you change the source file, the old Main.class stays exactly as it was. Compile again before you run again. Forgetting this is the most common mistake on the first day.

Now the shape of a program. Java keeps all code inside classes. A class is a named container for code. The public class must have the same name as its file, so a class called Main goes in Main.java. Inside the class we write a method called main. A method is a named block of code that does one job. When you run a program, the JVM looks for main and starts there.

Inside a method, each instruction is a statement. Most statements end with a semicolon. Curly braces { } mark where a class or a method begins and ends. The statement System.out.println prints text and then moves to a new line. System.out.print does the same without moving to a new line. Text must be inside double quotation marks.

Java 25 also allows a much shorter program form. Your course uses the classic form shown here, which works on every version. To run an example on this page, press Run under it. You can press Edit code, change something, and press Run again.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        System.out.println("My name is Leon.");
        System.out.println(2 + 3);
    }
}

Hello, Java!
My name is Leon.
5

Main.java.txt

Main.java

java Main    (typed after editing Main.java, without compiling again)

javac Main.java
java Main

system.out.println("Hi");

System.out.println("Hi");

Variables and types

Goal You can declare variables of type int, double, boolean, char and String, change their values, and predict what division and + give.

A variable is a named place in the computer's memory that holds one value. You choose the name. Java also needs to know what kind of value the variable may hold. That kind is called the variable's type.

These are the five types to learn first:
int: a whole number, such as 7 or -3.
double: a number with a decimal part, such as 1.5.
boolean: either true or false.
char: one character in single quotation marks, such as 'A'.
String: text in double quotation marks, such as "Mia". Write String with a capital S.

You declare a variable by writing its type, its name and a first value: int apples = 7; The = sign means "store the value on the right into the name on the left". It does not mean "is equal to", as in maths. Later you can store a new value: apples = apples + 1; Read it as "take the old value of apples, add 1, and store the result back in apples". You do not write the type again, because the variable already exists.

Java checks types before the program runs. It will not store 2.5 in an int, because the .5 would be lost. It also wants every variable to have a value before you use it.

For arithmetic you have + - * / and %, where % gives the remainder after division. If both sides of / are int, the answer is an int and the decimal part is cut off: 7 / 2 is 3, not 3.5. If one side is a double, the answer is a double: 7 / 2.0 is 3.5. Java does * and / before + and -, and otherwise works from left to right.

The + sign also joins text. Joining text is called concatenation. "Mia" + " is " + 7 gives the text Mia is 7. Because Java works from left to right, the order matters, as the mistakes below show.

public class Main {
    public static void main(String[] args) {
        String name = "Mia";
        int apples = 7;
        int people = 2;
        double price = 1.5;
        boolean cheap = price < 2.0;
        char grade = 'A';

        System.out.println(name + " has grade " + grade);
        System.out.println("whole share: " + apples / people);
        System.out.println("left over: " + apples % people);
        System.out.println("exact share: " + apples / 2.0);
        System.out.println("total cost: " + apples * price);
        System.out.println("cheap? " + cheap);

        apples = apples + 1;
        System.out.println("apples now: " + apples);
    }
}

Mia has grade A
whole share: 3
left over: 1
exact share: 3.5
total cost: 10.5
cheap? true
apples now: 8

int half = 7 / 2.0;

double half = 7 / 2.0;

System.out.println("Sum: " + 2 + 3);

System.out.println("Sum: " + (2 + 3));    // prints Sum: 5

int total;
System.out.println(total);

int total = 0;
System.out.println(total);

char grade = "A";

char grade = 'A';

Decisions and repeats: if and for

Goal You can make a program choose between two paths with if and else, and repeat work a set number of times with for.

Normally Java runs the statements from top to bottom, once each. Two tools change that. An if statement chooses whether to run some statements. A for statement repeats some statements.

An if statement has a condition in brackets, followed by a block. A block is a group of statements inside curly braces. The condition must be a boolean, which means true or false. If it is true, Java runs the block. If it is false, Java skips the block, or runs the block after else when there is one. The else part is optional. To test several cases in order, write another if after else. Java takes the first block whose condition is true and skips the rest.

Conditions usually come from comparisons: < (less than), <= (less than or equal), > (greater than), >= (greater than or equal), == (equal) and != (not equal). You can combine conditions: && means and, || means or, and ! means not. Watch the difference: two equals signs, ==, compare two values. One equals sign, =, stores a value.

A for loop repeats a block. A loop is any statement that runs a block again and again. The brackets of a for hold three parts separated by semicolons, as in for (int i = 1; i <= 5; i++). The start, int i = 1, creates a counter named i and sets it to 1. The test, i <= 5, is checked before every round. When it is false, the loop ends. The step, i++, adds 1 to i after every round. It is short for i = i + 1. Likewise i-- subtracts 1.

Tracing means following a program by hand, writing down the value of each variable after each step. It is how you find out what code does without running it, and it is a skill worth practising on paper.

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total = total + i;
            if (i % 2 == 0) {
                System.out.println(i + " is even, total " + total);
            } else {
                System.out.println(i + " is odd, total " + total);
            }
        }
        System.out.println("final total " + total);
    }
}

1 is odd, total 1
2 is even, total 3
3 is odd, total 6
4 is even, total 10
5 is odd, total 15
final total 15

if (score = 50) {

if (score == 50) {

for (int i = 0; i < 3; i++);
{
    System.out.println("hi");
}

for (int i = 0; i < 3; i++) {
    System.out.println("hi");
}

for (int i = 1; i < 5; i++) {
    System.out.println(i);
}    // meant to print 1 to 5

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

if (x > 0)
    System.out.println("positive");
    System.out.println("done");

if (x > 0) {
    System.out.println("positive");
}
System.out.println("done");

Methods: naming a piece of work

Goal You can write a method with parameters and a return value, and call it from main.

A method is a named block of code. You write it once and use it as many times as you like. Using it is called calling it. Methods save you from copying the same lines again and again, and a good name tells the reader what the lines do.

A method has four parts. In static int square(int n) { return n * n; } they are these. The return type, int, says what kind of value comes back. The name is square. The parameter list, (int n), declares the inputs: a parameter is a variable that receives an input. The body, in braces, is the code that runs. The word static is needed for now because main is static. Leave it in for the time being. Lesson 7 shows methods without it.

To call a method, write its name and, in brackets, the values to give it: square(6). These values are the arguments. Java copies each argument into the matching parameter. The statement return sends a value back and ends the method. The call square(6) then stands for the value 36, and you can use it anywhere a value fits, for example inside println, or on the right of an = sign.

Some methods give nothing back. Their return type is void, and they need no return statement. In the example, greet is like this.

A variable created inside a method, parameters included, is local. It exists only while the method runs, and no other method can see it. Because arguments are copied, changing a parameter inside a method does not change the variable in the code that called the method, which is known as the caller. The example shows this with n.

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

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

    static int addOne(int n) {
        n = n + 1;
        return n;
    }

    public static void main(String[] args) {
        greet("Iris");
        int result = square(6);
        System.out.println("6 squared is " + result);
        System.out.println(square(square(2)));

        int n = 5;
        int bigger = addOne(n);
        System.out.println("n is " + n + ", bigger is " + bigger);
    }
}

Hello, Iris!
6 squared is 36
16
n is 5, bigger is 6

static int square(int n) {
    int result = n * n;
}

static int square(int n) {
    int result = n * n;
    return result;
}

int n = 5;
addOne(n);
System.out.println(n);    // expecting 6

int n = 5;
n = addOne(n);
System.out.println(n);    // prints 6

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

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

Arrays: many values in a row

Goal You can create an array, read and change its elements by index, loop over it, and print it.

An array holds a fixed number of values of the same type, stored in a row. Picture a row of numbered boxes. Each box is an element. The number of a box is its index. Indexes start at 0, not at 1. An array with 3 elements has the indexes 0, 1 and 2.

You can create an array with values: int[] scores = {80, 95, 70}; The type int[] means "array of int". Or you can create one of a given size: int[] blanks = new int[3]; Every element then starts with a default value: 0 for numbers, false for boolean, and null for String. null means "no object".

Read an element with scores[0]. Change one with scores[1] = 100; The size is scores.length. Notice that length has no brackets after it. The size can never change after the array is created.

The last valid index is length - 1. An index outside 0 to length - 1 is not a compile error. The program stops when it reaches that line, with an ArrayIndexOutOfBoundsException. An exception is Java's way of reporting a problem while the program runs. Lesson 8 shows how to read one.

To visit every element, loop over the indexes: for (int i = 0; i < scores.length; i++). There is also a shorter form, the for-each loop: for (int s : scores) { ... } Read it as "for each int s in scores". The variable s takes each value in turn. Use it when you do not need the index.

Printing an array directly shows a code such as [I@6d06d69c, not the values. To see the values, put import java.util.Arrays; above the class and print Arrays.toString(scores). An import line tells Java which library class you mean. The library is the large collection of ready-made classes that comes with Java.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] scores = {80, 95, 70};
        System.out.println("first = " + scores[0]);
        System.out.println("length = " + scores.length);

        scores[1] = 100;
        System.out.println(Arrays.toString(scores));

        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            total = total + scores[i];
        }
        System.out.println("total = " + total);

        for (int s : scores) {
            System.out.println("score: " + s);
        }

        int[] blanks = new int[3];
        System.out.println(Arrays.toString(blanks));
    }
}

first = 80
length = 3
[80, 100, 70]
total = 250
score: 80
score: 100
score: 70
[0, 0, 0]

for (int i = 0; i <= scores.length; i++) {
    System.out.println(scores[i]);
}

for (int i = 0; i < scores.length; i++) {
    System.out.println(scores[i]);
}

int[] copy = scores;
copy[0] = 0;

int[] copy = Arrays.copyOf(scores, scores.length);
copy[0] = 0;    // scores is unchanged

System.out.println(scores.length());

System.out.println(scores.length);

Strings, and == versus equals

Goal You can use common String methods and compare two strings correctly.

A String is a piece of text, made of characters in order. You write a string value in double quotation marks. String is not a simple type like int. It is a class, and every string value is an object. An object is a value created from a class, and it lives somewhere in memory. A variable of type String does not hold the text itself. It holds a reference, which says where the object is. Think of a reference as a label that points to the object.

You use an object's methods with a dot, as in word.length(). These are useful: length() gives the number of characters. charAt(i) gives the character at index i, counted from 0, like an array. substring(a, b) gives the characters from index a up to, but not including, index b. indexOf("l") gives the index of the first match, or -1 if there is none. toUpperCase() and toLowerCase() change capital letters. Note that length() for a String has brackets, unlike length for an array.

A String can never be changed after it is made. Methods such as toUpperCase() do not change the original. They return a new String. To keep the result, store it: word = word.toUpperCase();

Now == and equals. For references, == asks: do these two names point at the very same object? It does not ask whether the text matches. Two different objects can hold the same letters. The method equals asks: do these two strings contain the same characters? That is nearly always what you mean. So compare strings with a.equals(b), never with a == b. Use equalsIgnoreCase to ignore capital letters.

== sometimes seems to work. Java stores identical string literals (text typed directly in the code) only once, so two literals with the same text are the same object. But as soon as the text comes from somewhere else, such as the keyboard, a file or a calculation, == gives false. A bug that works in your tests and fails later is the worst kind. Always use equals.

public class Main {
    public static void main(String[] args) {
        String word = "hello";
        String typed = new String("hello");    // pretend this text came from the keyboard

        System.out.println("same text? " + word.equals(typed));
        System.out.println("same object? " + (word == typed));

        String shout = word.toUpperCase();
        System.out.println(shout + " " + word);
        System.out.println(word.length());
        System.out.println(word.charAt(1));
        System.out.println(word.substring(1, 3));
        System.out.println(word.indexOf("l"));
        System.out.println("ignoring case? " + word.equalsIgnoreCase("HELLO"));
    }
}

same text? true
same object? false
HELLO hello
5
e
el
2
ignoring case? true

if (answer == "yes") {

if ("yes".equals(answer)) {

name.toUpperCase();
System.out.println(name);

name = name.toUpperCase();
System.out.println(name);

String part = "hello".substring(1, 3);    // expecting "ell"

String part = "hello".substring(1, 4);    // ell

Your first class, with a constructor

Goal You can write a small class with fields, a constructor and methods, create objects from it with new, and call their methods.

So far you used types that Java provides. A class lets you make your own type. A class is a blueprint: it says what data each object has and what each object can do. An object is one thing built from the blueprint. One class, such as Player, can make many objects, and each object has its own data.

The data are called fields. A field is a variable that belongs to an object. You declare it inside the class but outside every method. We mark fields private. private means that only code inside the same class may use the field. This protects the data, and other code must go through the class's methods.

A method without the word static works on one particular object. Calling addPoints(5) on Leon's object changes Leon's score and nobody else's. Inside the class, such a method uses the fields by their names.

A constructor is a special method that runs when an object is created with new. It has the same name as the class and no return type, not even void. Its job is to give the fields their first values. new Player("Leon") creates the object, runs the constructor with "Leon" as the argument, and gives you a reference to the new object.

Inside the constructor, the parameter and the field may both be called name. Writing this.name means "the name field of this object". Writing name alone means the parameter. So this.name = name; stores the argument in the field.

Where does a class go? In real projects each class gets its own file, named after it. To keep this example in one file, the extra class goes above public class Main. Only the class called Main may be public there.

class Player {
    private String name;
    private int score;

    Player(String name) {
        this.name = name;
        this.score = 0;
    }

    void addPoints(int points) {
        score = score + points;
    }

    String describe() {
        return name + " has " + score + " points";
    }
}

public class Main {
    public static void main(String[] args) {
        Player leon = new Player("Leon");
        Player mia = new Player("Mia");

        leon.addPoints(5);
        leon.addPoints(3);
        mia.addPoints(10);

        System.out.println(leon.describe());
        System.out.println(mia.describe());
    }
}

Leon has 8 points
Mia has 10 points

Player leon = Player("Leon");

Player leon = new Player("Leon");

void Player(String name) {
    this.name = name;
}

Player(String name) {
    this.name = name;
}

Player(String name) {
    name = name;
    this.score = 0;
}

Player(String name) {
    this.name = name;
    this.score = 0;
}

Reading a compile error and a stack trace

Goal You can find the line and the cause in a javac error message and in an exception stack trace.

Programs go wrong in three ways. A compile error means javac refuses to build the program, and nothing runs. A runtime error means the program starts, and then Java stops it at some line and prints a stack trace. A wrong answer means the program runs to the end but prints the wrong thing, and Java says nothing. The first two come with a message. This lesson is about reading those messages. The mistakes below show real ones.

Read a compile error from the top. The first line has three parts: the file and line number (such as Main.java:4), the word error, and what is wrong (such as cannot find symbol). The next line repeats the code from that line, with a caret ^ under the spot where Java got stuck. Some errors add detail lines, such as symbol: variable totl and location: class Main, which say which name Java does not know and where it looked. The last line counts the errors.

Three habits help. Fix the first error first, because later ones are often caused by it. A single missing brace can produce a dozen. Compile again after each fix. Next, the line number is where Java noticed the problem, and the real mistake can be a line above. Finally, treat the message as a hint, not a diagnosis. cannot find symbol only says that Java does not know a name.

A stack trace appears when an exception is not handled. An exception is an event that means something went wrong while the program was running, such as dividing by zero or using an index outside an array. The program stops at that point. The trace begins with a line that names the exception and gives a message. Then come lines that start with at. Each one is a method that was running, with the file name and line number in brackets. The top at line is where the exception happened. The line below it is the method that called it, and so on down to main. Find the first line that names your own file, such as Main.java, and open that file at that line. Lines that mention java.base or java.util are Java's own code. The cause is almost always in yours.

You can handle an exception instead of letting it stop the program. Put the risky statements in a try block. If an exception of the named kind happens there, Java skips the rest of the try block and runs the catch block. The program then carries on after the catch. The example works this way.

public class Main {
    static int readAge(String text) {
        return Integer.parseInt(text);
    }

    public static void main(String[] args) {
        System.out.println("start");
        try {
            System.out.println("age is " + readAge("12"));
            System.out.println("age is " + readAge("twelve"));
            System.out.println("this line is skipped");
        } catch (NumberFormatException e) {
            System.out.println("not a whole number");
        }
        System.out.println("done");
    }
}

start
age is 12
not a whole number
done

public class Main {
    public static void main(String[] args) {
        int total = 5
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(totl);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(total);
    }
}

public class Main {
    static int average(int total, int count) {
        return total / count;
    }

    public static void main(String[] args) {
        System.out.println(average(10, 0));
    }
}

static int average(int total, int count) {
    if (count == 0) {
        return 0;
    }
    return total / count;
}