Java Classes: Defining Fields, Methods and Objects

A Class Is a Blueprint

Up to now your code has lived in methods that pass plain values around. A class lets you bundle related data and the behavior that operates on it into a single named type. The class is the blueprint; the actual things you work with are objects created from it.

A class declares two kinds of members: fields (the data each object holds) and methods (what each object can do).

class Dog {
    String name;          // a field: every Dog has a name
    int age;              // another field

    void bark() {         // a method: behavior every Dog has
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // create an object from the blueprint
        d.name = "Rex";       // set its fields
        d.age = 3;
        d.bark();             // call its method
    }
}

new Dog() builds an object in memory and hands you a reference to it. d.name and d.bark() reach into that specific object.

Each Object Has Its Own State

The whole point of a class is that you can stamp out many independent objects, each carrying its own field values. Changing one never touches another.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex and bella are two separate objects. Each has its own name, so each bark() prints a different value. This per-object data is called instance state.

Fields and Methods Work Together

Methods inside a class can read and update that object's own fields directly - no need to pass them in as parameters. The method already "lives on" the object whose data it touches.

class Counter {
    int count;            // starts at 0 by default

    void increment() {
        count++;          // updates this object's field
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Notice increment() takes no arguments. It works on the field belonging to whichever Counter you called it on. This is the difference between a class method and a free-floating static method: the method has an implicit object to act upon.

The this Keyword

Inside a method, this is a reference to the object the method was called on. You usually do not need it - writing count already means this.count. But this becomes essential when a parameter name collides with a field name, which happens constantly in setters and constructors.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x is the field; x is the parameter
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

A common beginner mistake is writing x = x; inside move. That just assigns the parameter to itself and leaves the field untouched - the compiler will not warn you, and your object silently keeps its old values. this.x = x; is what actually updates the field.

Default Field Values and null References

When you create an object, its fields are not left as garbage - Java initializes them to defaults: 0 for numbers, false for boolean, and null for object references like String. That null default is the source of a classic crash.

class User {
    String name;          // not assigned, so it defaults to null
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name is null because nobody set it, so calling .length() on it throws a NullPointerException. Always assign meaningful values to an object before using its fields - which is exactly the problem constructors solve.

Organizing Code Around Classes

Real programs model their domain as classes that hold data and the operations on it together. Here a single BankAccount class keeps a balance and guards how it changes:

class BankAccount {
    String owner;
    double balance;

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

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // not enough funds
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

The data (balance) and the rules for changing it (deposit, withdraw) live in one place. Code elsewhere asks the account to do things rather than poking at its numbers directly - the foundation of clean, maintainable design.

Next: Constructors

Setting every field by hand after new is tedious and easy to forget - and as you just saw, a forgotten field leaves a null waiting to crash. A constructor lets you require and initialize an object's fields the moment it is created, so a BankAccount can never exist without an owner. That is the next page.