Java Classes and Objects

class Dog {
    String name;
    int age;

    void bark() {
        System.out.println(name + " says woof!");
    }
}

• name and age are fields: variables that belong to each object.
• bark() is an instance method. It has no static, because it works on one particular dog's data.
• Class names start with a capital letter: Dog, BankAccount, Student.

A file may contain several classes, but only one can be public, and it must match the file name. In larger projects, each class usually gets its own file.

Dog rex = new Dog();
rex.name = "Rex";
rex.age = 3;
rex.bark();   // Rex says woof!

new Dog() builds a new object in memory. The variable rex holds a reference to it. Use the dot to reach an object's fields and methods: rex.name, rex.bark(). Every object has its own copy of the fields, so changing rex.age doesn't affect any other dog.

A constructor is a special method that runs when an object is created. It has the same name as the class and no return type:

class Dog {
    String name;
    int age;

    Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Dog bella = new Dog("Bella", 5);

this means "the object being built". this.name = name copies the parameter name into the object's field name. Constructors make sure every object starts life with sensible values.

To stop other code from putting objects into a broken state, mark fields private and provide methods to read or change them safely:

class BankAccount {
    private double balance;

    double getBalance() { return balance; }

    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
}

Now nobody can write account.balance = -500;. They have to go through deposit(), which checks the amount. Hiding data behind methods like this is called encapsulation.

Printing an object you've written yourself gives something like Dog@1b6d3586: the class name and a code based on the object's hash code. Java calls the object's toString() method whenever it needs text, and the default version isn't very helpful. Write your own to describe the object:

class Dog {
    String name;
    int age;

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

Now System.out.println(rex) prints Rex (3), and so does "Dog: " + rex. @Override asks the compiler to check that you really are replacing an inherited method, so a typo such as tostring is reported as an error. Comparing objects for equality works the same way: == checks whether two references point to the same object, and you override equals() to compare their contents.

Fields and methods without static belong to each object. Fields and methods marked static belong to the class itself and are shared by every object:

class Ticket {
    static int issued = 0;   // one counter for all tickets
    int number;

    Ticket() {
        issued++;
        number = issued;
    }
}

After creating three tickets, each has its own number (1, 2 and 3), while Ticket.issued is 3. Use static fields for values that really are shared, such as counters and constants, and keep everything else as instance fields. The object model lesson explores references and object identity further.