Java-Klassen: Felder, Methoden und Objekte definieren

Eine Klasse ist ein Bauplan

Bisher lebte dein Code in Methoden, die schlichte Werte hin und her reichen. Eine Klasse erlaubt es dir, zusammengehörige Daten und das Verhalten, das auf ihnen arbeitet, in einem einzigen benannten Typ zu bündeln. Die Klasse ist der Bauplan; die eigentlichen Dinge, mit denen du arbeitest, sind die daraus erzeugten Objekte.

Eine Klasse deklariert zwei Arten von Mitgliedern: Felder (die Daten, die jedes Objekt hält) und Methoden (was jedes Objekt tun kann).

class Dog {
    String name;          // ein Feld: jeder Dog hat einen Namen
    int age;              // ein weiteres Feld

    void bark() {         // eine Methode: Verhalten, das jeder Dog hat
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // ein Objekt aus dem Bauplan erzeugen
        d.name = "Rex";       // seine Felder setzen
        d.age = 3;
        d.bark();             // seine Methode aufrufen
    }
}

new Dog() baut ein Objekt im Speicher und gibt dir eine Referenz darauf. d.name und d.bark() greifen auf genau dieses Objekt zu.

Jedes Objekt hat seinen eigenen Zustand

Der ganze Sinn einer Klasse ist, dass du viele unabhängige Objekte herstellen kannst, von denen jedes seine eigenen Feldwerte trägt. Eines zu ändern berührt nie ein anderes.

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 und bella sind zwei getrennte Objekte. Jedes hat seinen eigenen name, also gibt jedes bark() einen anderen Wert aus. Diese objektbezogenen Daten nennt man Instanzzustand.

Felder und Methoden arbeiten zusammen

Methoden innerhalb einer Klasse können die eigenen Felder des Objekts direkt lesen und aktualisieren – ohne sie als Parameter übergeben zu müssen. Die Methode „lebt bereits auf“ dem Objekt, dessen Daten sie anfasst.

class Counter {
    int count;            // beginnt standardmäßig bei 0

    void increment() {
        count++;          // aktualisiert das Feld dieses Objekts
    }

    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
    }
}

Beachte, dass increment() keine Argumente annimmt. Es arbeitet auf dem Feld, das zu dem Counter gehört, auf dem du es aufgerufen hast. Das ist der Unterschied zwischen einer Klassenmethode und einer freischwebenden statischen Methode: Die Methode hat ein implizites Objekt, auf das sie wirkt.

Das Schlüsselwort this

Innerhalb einer Methode ist this eine Referenz auf das Objekt, auf dem die Methode aufgerufen wurde. Meist brauchst du es nicht – count zu schreiben bedeutet bereits this.count. Doch this wird unverzichtbar, wenn ein Parametername mit einem Feldnamen kollidiert, was in Settern und Konstruktoren ständig vorkommt.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x ist das Feld; x ist der 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)
    }
}

Ein häufiger Anfängerfehler ist, in move x = x; zu schreiben. Das weist den Parameter nur sich selbst zu und lässt das Feld unberührt – der Compiler warnt dich nicht, und dein Objekt behält stillschweigend seine alten Werte. this.x = x; ist das, was das Feld tatsächlich aktualisiert.

Standardwerte von Feldern und null-Referenzen

Wenn du ein Objekt erzeugst, bleiben seine Felder nicht als Müll zurück – Java initialisiert sie mit Standardwerten: 0 für Zahlen, false für boolean und null für Objektreferenzen wie String. Dieser null-Standardwert ist die Quelle eines klassischen Absturzes.

class User {
    String name;          // nicht zugewiesen, also standardmäßig null
}

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

u.name ist null, weil es niemand gesetzt hat, also wirft der Aufruf von .length() darauf eine NullPointerException. Weise einem Objekt immer sinnvolle Werte zu, bevor du seine Felder verwendest – und genau dieses Problem lösen Konstruktoren.

Code rund um Klassen organisieren

Echte Programme modellieren ihre Domäne als Klassen, die Daten und die darauf wirkenden Operationen zusammenhalten. Hier hält eine einzige BankAccount-Klasse einen Kontostand und kontrolliert, wie er sich ändert:

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;     // nicht genug Guthaben
    }
}

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);
    }
}

Die Daten (balance) und die Regeln zu ihrer Änderung (deposit, withdraw) leben an einem Ort. Code an anderer Stelle bittet das Konto, etwas zu tun, statt direkt an seinen Zahlen herumzustochern – die Grundlage eines sauberen, wartbaren Designs.

Als Nächstes: Konstruktoren

Jedes Feld nach new von Hand zu setzen ist mühsam und leicht zu vergessen – und wie du gerade gesehen hast, hinterlässt ein vergessenes Feld ein null, das auf einen Absturz wartet. Ein Konstruktor erlaubt es dir, die Felder eines Objekts genau im Moment seiner Erzeugung zu verlangen und zu initialisieren, sodass ein BankAccount niemals ohne Eigentümer existieren kann. Darum geht es auf der nächsten Seite.