Einstieg in Klassen und Objekte

Java ist eine objektorientierte Programmiersprache. Was heißt das? Bisher haben wir vor allem Daten (Variablen, Arrays) und Code (Methoden) getrennt behandelt. Bei der Objektorientierung packt man beides zusammen: Daten und die dazugehörigen Operationen bilden eine logische Einheit – ein Objekt. Diese Lektion ist nur der Einstieg – die ganze OOP-Welt mit Vererbung, Polymorphismus und Interfaces folgt in K40b – Java Fortgeschritten.

Die Analogie: Stell dir vor, du baust Häuser. Du zeichnest einmal einen Bauplan – sagen wir, für ein bestimmtes Haus-Modell. Mit diesem Bauplan kannst du jetzt 1, 10 oder 1000 Häuser bauen. Jedes Haus ist eigenständig: es hat eine eigene Adresse, eine eigene Farbe, einen eigenen Besitzer. Aber alle wurden nach demselben Plan gebaut. In Java: die Klasse ist der Bauplan. Die Objekte sind die tatsächlich gebauten Häuser. Jedes Objekt hat seine eigenen Werte für die Eigenschaften, aber alle teilen sich dieselbe Struktur und dieselben Methoden.

1) Klasse vs. Objekt: Bauplan vs. tatsächliches Haus

Eine Klasse ist eine Bauanleitung. Sie beschreibt: welche Eigenschaften (Attribute) hat ein Objekt dieser Art? Welche Aktionen (Methoden) kann es ausführen? Aus einer Klasse erstellst du mit new beliebig viele Objekte (auch „Instanzen" genannt) – jedes mit eigenen Werten:

Klasse Auto → mehrere Objekte

⌧ Klasse (der Bauplan)

public class Auto {
  // Attribute
  String marke;
  String farbe;
  int kmStand;

  // Methode
  void fahre(int km) {
    kmStand += km;
  }
}

⌥ Objekte (die echten Autos)

Auto a1 = new Auto();

marke: "BMW"
farbe: "schwarz"
kmStand: 45000

Auto a2 = new Auto();

marke: "VW"
farbe: "rot"
kmStand: 12000

Auto a3 = new Auto();

marke: "Tesla"
farbe: "weiß"
kmStand: 800

Jedes Objekt hat seine eigenen Werte für die Attribute. Wenn ich a1.fahre(50) aufrufe, ändert sich nur der kmStand von a1 – a2 und a3 bleiben unverändert. Die Methode fahre() ist aber für alle gleich definiert (steht ja in der Klasse). Die Klasse selbst ist KEIN Objekt – sie ist nur die Vorlage. Aus ihr werden mit new die Objekte erstellt.

2) Die Bestandteile einer Klasse

Eine Klasse hat normalerweise drei Arten von Mitgliedern (genannt „Member"): Attribute (Daten), Konstruktoren (zur Initialisierung) und Methoden (Verhalten). Hier ein vollständiges Beispiel:

Vollständige Klasse mit allen Member-Typen

public class Hund {
  // === Attribute (Daten des Hundes) ===ATTRIBUT
  private String name;
  private int alter;
  private String rasse;

  // === Konstruktor: wird bei "new" aufgerufen ===KONSTRUKTOR
  public Hund(String name, int alter, String rasse) {
    this.name = name;
    this.alter = alter;
    this.rasse = rasse;
  }

  // === Methode: Verhalten des Hundes ===METHODE
  public void bellen() {
    System.out.println(name + " sagt Wuff!");
  }

  // === Getter: liefern Attribut-Werte ===GETTER
  public String getName() {
    return name;
  }
}

Drei Konzepte sind wichtig: this verweist auf „dieses spezifische Objekt" – nötig, wenn Parameter-Name = Attribut-Name (this.name = Attribut, name = Parameter). private macht das Attribut von außen unzugänglich – nur die Klasse selbst darf direkt drauf zugreifen. Das nennt sich Kapselung. Von außen geht man über Getter (lesen) und Setter (schreiben) – Methoden mit kontrollierter Logik.

3) Live-Demo: Objekte erstellen

Du kannst von einer Klasse beliebig viele Objekte erstellen. Jedes ist eigenständig und liegt im Heap-Speicher. Klick auf den Button und sieh wie ein neues Objekt erscheint:

Hund-Objekte erstellen

name: alter: rasse:

Anzahl Objekte im Heap: 0

Beim new Hund(...) passiert Folgendes: 1) Java reserviert Speicher im Heap für ein neues Hund-Objekt. 2) Der Konstruktor wird aufgerufen mit deinen Argumenten. 3) Die Attribute werden gesetzt (this.name = name, ...). 4) Eine Referenz auf das neue Objekt wird zurückgegeben. Die Variable im Stack hält nur die Referenz (Adresse) – das Objekt selbst lebt im Heap. Bei Hund h = new Hund("Bello", 5, "Dackel"); zeigt h auf das Objekt – aber „IST" nicht das Objekt.

4) Stack vs. Heap: Wo lebt das Objekt?

Eine entscheidende Eigenheit von Java: primitive Variablen (int, double, ...) leben im Stack. Objekte (alles mit new erstellte) leben im Heap. Die Variable die du im Stack siehst ist nur eine Referenz auf das Objekt – wie ein Wegweiser zum echten Objekt. Das ist auch der Grund warum „Pass-by-Value" bei Objekten anders wirkt (siehe Methoden, L6).

Memory: Stack vs. Heap

Stack (lokale Variablen)

int alter = 25 primitiv

double preis = 19.99 primitiv

Hund h1 → @a3f Referenz

Hund h2 → @b7c Referenz

Heap (Objekte)

Hund @a3f
  name = "Bello"
  alter = 5
  rasse = "Dackel"

Hund @b7c
  name = "Rex"
  alter = 3
  rasse = "Bulldogge"

Wichtige Folgen davon: 1) Wenn du Hund h2 = h1; machst, kopierst du nur die Referenz – beide Variablen zeigen aufs SELBE Objekt im Heap. Eine Änderung über h1 sieht man auch über h2! 2) Wenn keine Referenz mehr auf ein Heap-Objekt zeigt, räumt der Garbage Collector es automatisch auf – Java macht das im Hintergrund. 3) null bedeutet: die Referenz zeigt auf nichts. Aufruf auf null → NullPointerException.

5) Objekte verwenden – die Punkt-Notation

Hast du ein Objekt, kommst du mit dem Punkt-Operator an seine Attribute und Methoden:

// Objekt erstellen

Hund bello = new Hund("Bello", 5, "Dackel");

// Methode aufrufen

bello.bellen();          // Ausgabe: Bello sagt Wuff!

// Attribut lesen über Getter

String n = bello.getName();   // "Bello"

// Mehrere Hunde in einem Array (siehe Lektion 5)

Hund[] hunde = new Hund[3];

hunde[0] = new Hund("Bello", 5, "Dackel");

hunde[1] = new Hund("Rex", 3, "Bulldogge");

hunde[2] = new Hund("Lassie", 7, "Collie");

for (Hund h : hunde) {

    h.bellen();

}

6) Vorgeschmack: was kommt in K40b?

Das hier war nur der Einstieg. Die volle OOP-Welt enthält noch viel mehr Konzepte, die in K40b – Java Fortgeschritten dran sind:

Kapselung mit private/public richtig nutzen, Gettern und Settern
Vererbung: Tierklasse → Hund erbt davon, ergänzt mit Spezifischem
Polymorphismus: Methoden in der Unterklasse überschreiben
Interfaces: Verträge, die Klassen erfüllen müssen
Statische Member, abstrakte Klassen, innere Klassen, generische Typen

Zusammenfassung

Klasse = Bauplan, Objekt = konkrete Instanz. new Klassenname(...) erstellt ein Objekt. Klasse enthält: Attribute (Daten), Konstruktor (Initialisierung, gleicher Name wie Klasse), Methoden (Verhalten). this verweist auf das aktuelle Objekt. private schützt Attribute, Zugriff über Getter/Setter. Primitive leben im Stack, Objekte im Heap – Variablen halten Referenzen. Zugriff mit Punkt-Notation: obj.attribut, obj.methode(). Garbage Collector räumt unbenutzte Objekte auf.