Tag 2 : Attribute & Methoden

Von Nova Trent, Junior Entwicklerin bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Einsteiger
Lesezeit: 30–35 Minuten
Voraussetzungen: Tag 1 abgeschlossen (Klassen, Objekte, new)

---

📋 Kursübersicht: Java OOP in 10 Tagen

Tag	Thema	Status
1	OOP-Konzepte & erste Klasse	✅ Abgeschlossen
→ 2	Attribute & Methoden	📍 Du bist hier
3	Datenkapselung & Sichtbarkeit	⏳
4	Konstruktoren	⏳
5	Konstanten & Static	🔴 KOPFNUSS
6	Vererbung – Grundlagen	⏳
7	Vererbung – Polymorphie & Abstrakte Klassen	⏳
8	Typumwandlung & instanceof	⏳
9	Interfaces & Enumerationen	⏳
10	Ausnahmebehandlung	🔴 KOPFNUSS

Voraussetzung: Tag 1 abgeschlossen
Folgekurs: Erweiterte Techniken (Kurs 3)

---

🔄 Kurz-Wiederholung: Challenge von Tag 1

Die Aufgabe war: Erstelle eine Klasse Buch mit Attributen titel, autor, seiten und einer Methode info().

Lösung:

// Datei: de/deinname/bibliothek/Buch.java
package de.deinname.bibliothek;

public class Buch {
    String titel;
    String autor;
    int seiten;
    
    void info() {
        System.out.println(titel + " von " + autor + " (" + seiten + " Seiten)");
    }
}

// Datei: de/deinname/bibliothek/Main.java
package de.deinname.bibliothek;

public class Main {
    public static void main(String[] args) {
        Buch buch1 = new Buch();
        buch1.titel = "Clean Code";
        buch1.autor = "Robert C. Martin";
        buch1.seiten = 464;
        buch1.info();  // Clean Code von Robert C. Martin (464 Seiten)
        
        Buch buch2 = new Buch();
        buch2.titel = "Effective Java";
        buch2.autor = "Joshua Bloch";
        buch2.seiten = 416;
        buch2.info();  // Effective Java von Joshua Bloch (416 Seiten)
    }
}

Hattest du’s? Wenn ja — nice! Wenn nicht — kein Problem, heute lernst du genau das im Detail.

---

⚡ Das Wichtigste in 30 Sekunden

Dein Problem: Deine Klassen haben Attribute und Methoden, aber du weißt nicht genau, wie die zusammenspielen.

Die Lösung: Attribute speichern den Zustand, Methoden definieren das Verhalten — und this verbindet beides.

Heute lernst du:

• ✅ Instanzvariablen vs. lokale Variablen — wo liegt der Unterschied?
• ✅ Methoden richtig definieren — Parameter, Rückgabewerte, Signatur
• ✅ Die this-Referenz — warum sie wichtig ist
• ✅ Methodenüberladung — gleicher Name, unterschiedliche Parameter

Für wen ist dieser Artikel?

• 🌱 OOP-Neulinge: Du lernst Attribute und Methoden von Grund auf
• 🌿 OOP-Umsteiger: Du siehst Java-spezifische Eigenheiten (vs. C#, PHP)
• 🌳 Profis: Im Bonus: Varargs, Method References, Lombok

Zeit-Investment: 30–35 Minuten

---

👋 Nova: „Jetzt wird’s praktisch!“

Hi! 👋

Nova hier.

Gestern hast du deine erste Klasse geschrieben. Ein Auto mit farbe und ps. Cool!

Aber mal ehrlich — das Auto konnte noch nicht viel. Es hatte Eigenschaften, aber kaum Verhalten. Heute ändern wir das.

Ich zeige dir, wie du Methoden schreibst, die Parameter entgegennehmen und Werte zurückgeben. Wie du mit der this-Referenz arbeitest. Und warum du dieselbe Methode mehrfach mit unterschiedlichen Parametern definieren kannst.

Real talk: Als ich das erste Mal this.farbe = farbe gesehen habe, war ich komplett lost. „Häh?! Was ist der Unterschied?!“ Heute erkläre ich dir genau das — so, dass es klickt.

Ready? Los geht’s! 🚀

---

🟢 GRUNDLAGEN

Attribute — Der Zustand eines Objekts

Attribute (auch „Felder“ oder „Instanzvariablen“ genannt) speichern den Zustand eines Objekts.

public class Auto {
    // Attribute — Was HAT ein Auto?
    String farbe;      // "Rot", "Blau", ...
    int ps;            // 150, 200, ...
    String marke;      // "VW", "BMW", ...
    boolean laeuft;    // true oder false
}

Jedes Objekt hat seine eigenen Werte:

Auto auto1 = new Auto();
auto1.farbe = "Rot";
auto1.ps = 150;

Auto auto2 = new Auto();
auto2.farbe = "Blau";
auto2.ps = 200;

// auto1 und auto2 haben UNTERSCHIEDLICHE Werte!
System.out.println(auto1.farbe);  // Rot
System.out.println(auto2.farbe);  // Blau

Methoden — Das Verhalten eines Objekts

Methoden definieren, was ein Objekt tun kann.

public class Auto {
    String farbe;
    int ps;
    
    // Methoden — Was KANN ein Auto?
    void fahren() {
        System.out.println("Das Auto fährt!");
    }
    
    void hupen() {
        System.out.println("HUUUP! 📢");
    }
    
    void bremsen() {
        System.out.println("*quietsch* Gebremst!");
    }
}

Methoden aufrufen:

Auto meinAuto = new Auto();
meinAuto.fahren();   // Das Auto fährt!
meinAuto.hupen();    // HUUUP! 📢
meinAuto.bremsen();  // *quietsch* Gebremst!

Die Anatomie einer Methode

Jede Methode hat einen festen Aufbau:

Abbildung 1: Die Bestandteile einer Methodensignatur — Sichtbarkeit, Rückgabetyp, Name, Parameter und Rumpf.

Die Teile im Detail:

Teil	Beschreibung	Beispiel
Sichtbarkeit	Wer darf die Methode aufrufen?	public, private
Rückgabetyp	Was gibt die Methode zurück?	void, int, String
Name	Wie heißt die Methode?	fahren, berechneKosten
Parameter	Welche Werte braucht sie?	(int km, double preis)
Rumpf	Was macht die Methode?	{ ... }

Parameter und Argumente

Parameter sind Platzhalter in der Methodendefinition.
Argumente sind die echten Werte beim Aufruf.

public class Auto {
    // "km" ist ein PARAMETER (Platzhalter)
    void fahren(int km) {
        System.out.println("Fahre " + km + " Kilometer.");
    }
}

// Beim Aufruf:
Auto meinAuto = new Auto();
meinAuto.fahren(100);   // 100 ist das ARGUMENT (echter Wert)
meinAuto.fahren(250);   // 250 ist ein anderes Argument

Mehrere Parameter:

void fahren(int km, String ziel) {
    System.out.println("Fahre " + km + " km nach " + ziel);
}

meinAuto.fahren(150, "Berlin");  // Fahre 150 km nach Berlin

Rückgabewerte mit return

Methoden können Werte zurückgeben:

public class Auto {
    int tankinhalt = 50;  // Liter
    double verbrauch = 7.5;  // Liter pro 100km
    
    // Diese Methode GIBT einen Wert zurück
    double berechneReichweite() {
        double reichweite = (tankinhalt / verbrauch) * 100;
        return reichweite;  // Gibt den berechneten Wert zurück
    }
}

Rückgabewert verwenden:

Auto meinAuto = new Auto();
double kmBisLeer = meinAuto.berechneReichweite();
System.out.println("Reichweite: " + kmBisLeer + " km");
// Reichweite: 666.67 km

Wichtig:

• void = Methode gibt nichts zurück
• Jeder andere Typ (int, String, double, …) = Methode MUSS mit return einen Wert zurückgeben

// ❌ FEHLER: Kein return bei nicht-void Methode
int berechnePS() {
    int ps = 150;
    // return fehlt! → Compilerfehler
}

// ✅ RICHTIG:
int berechnePS() {
    int ps = 150;
    return ps;  // Wert zurückgeben
}

Instanzvariablen vs. Lokale Variablen

Das ist ein häufiger Stolperstein! Es gibt zwei Arten von Variablen:

Abbildung 2: Instanzvariablen gehören zum Objekt und leben so lange wie das Objekt. Lokale Variablen existieren nur während eines Methodenaufrufs.

Instanzvariablen (Attribute):

• Deklariert in der Klasse (außerhalb von Methoden)
• Jedes Objekt hat eigene Kopie
• Haben Default-Werte (null, 0, false)
• Leben so lange wie das Objekt

Lokale Variablen:

• Deklariert innerhalb von Methoden
• Existieren nur während des Methodenaufrufs
• Haben keine Default-Werte (müssen initialisiert werden!)
• Verschwinden nach dem Methodenaufruf

public class Auto {
    // INSTANZVARIABLE — gehört zum Objekt
    int gesamtKm = 0;
    
    void fahren(int km) {
        // LOKALE VARIABLE — existiert nur in dieser Methode
        double benzinVerbrauch = km * 0.07;
        
        gesamtKm = gesamtKm + km;  // Instanzvariable wird aktualisiert
        
        System.out.println("Verbraucht: " + benzinVerbrauch + " Liter");
    }
    // benzinVerbrauch existiert hier nicht mehr!
}

Die this-Referenz

this ist eine Referenz auf das aktuelle Objekt — also auf sich selbst.

Abbildung 3: this zeigt immer auf das Objekt, auf dem die Methode gerade aufgerufen wird.

Wann brauchst du this?

1. Wenn Parameter und Attribut gleich heißen:

public class Auto {
    String farbe;  // Attribut
    
    void setFarbe(String farbe) {  // Parameter heißt auch "farbe"!
        // Ohne this: Welches "farbe" meinst du?
        this.farbe = farbe;
        // ↑ Attribut    ↑ Parameter
    }
}

2. Um das aktuelle Objekt weiterzugeben:

void registrieren(Garage garage) {
    garage.aufnehmen(this);  // "Nimm MICH auf"
}

3. Um Methoden des eigenen Objekts aufzurufen:

void starten() {
    this.motorPruefen();  // Kann auch ohne this, aber manchmal klarer
    this.fahren(0);
}

Methodenüberladung (Overloading)

Du kannst mehrere Methoden mit gleichem Namen haben — solange die Parameter unterschiedlich sind:

public class Auto {
    
    // Version 1: Keine Parameter
    void fahren() {
        System.out.println("Das Auto fährt los!");
    }
    
    // Version 2: Mit Kilometer-Angabe
    void fahren(int km) {
        System.out.println("Das Auto fährt " + km + " km.");
    }
    
    // Version 3: Mit Kilometer und Ziel
    void fahren(int km, String ziel) {
        System.out.println("Das Auto fährt " + km + " km nach " + ziel);
    }
    
    // Version 4: Nur Ziel (andere Reihenfolge = andere Signatur!)
    void fahren(String ziel) {
        System.out.println("Das Auto fährt nach " + ziel);
    }
}

Aufruf:

Auto auto = new Auto();
auto.fahren();                    // Das Auto fährt los!
auto.fahren(100);                 // Das Auto fährt 100 km.
auto.fahren(100, "Hamburg");      // Das Auto fährt 100 km nach Hamburg
auto.fahren("München");           // Das Auto fährt nach München

Java wählt automatisch die richtige Version basierend auf den Argumenten!

Was zählt als „unterschiedlich“?

• ✅ Unterschiedliche Anzahl Parameter
• ✅ Unterschiedliche Typen
• ✅ Unterschiedliche Reihenfolge der Typen
• ❌ Nur unterschiedlicher Rückgabetyp reicht NICHT!

// ❌ FEHLER: Gleiche Parameter, nur anderer Rückgabetyp
int berechne(int x) { return x; }
double berechne(int x) { return x; }  // Compilerfehler!

---

🟡 PROFESSIONALS

Schon OOP-Erfahrung aus C#, C++, PHP? Hier sind die Java-Besonderheiten.

Für C#-Umsteiger: Properties vs. Getter/Setter

In C# hast du Properties mit get und set. In Java schreibst du das manuell:

// C# — Property (automatisch)
public class Auto {
    public string Farbe { get; set; }
}

auto.Farbe = "Rot";  // Setter
Console.WriteLine(auto.Farbe);  // Getter

// Java — Getter und Setter manuell
public class Auto {
    private String farbe;
    
    public String getFarbe() {
        return farbe;
    }
    
    public void setFarbe(String farbe) {
        this.farbe = farbe;
    }
}

auto.setFarbe("Rot");  // Setter-Methode
System.out.println(auto.getFarbe());  // Getter-Methode

Lombok macht’s einfacher (siehe Bonus)!

Für C++-Umsteiger: Keine Pointer-Arithmetik

In C++ arbeitest du oft mit Pointern. Java hat nur Referenzen:

// C++ — Pointer-Zugriff
Auto* auto = new Auto();
auto->fahren();      // Pfeil-Operator
(*auto).fahren();    // Dereferenzierung

// Java — Nur Punkt-Operator
Auto auto = new Auto();
auto.fahren();  // Immer Punkt, nie Pfeil

Wichtig: Java hat keinen -> Operator. Alles läuft über .

Für PHP-Umsteiger: Kein $this->, nur this.

// PHP
class Auto {
    private $farbe;
    
    public function setFarbe($farbe) {
        $this->farbe = $farbe;  // Dollar und Pfeil
    }
}

// Java
public class Auto {
    private String farbe;
    
    public void setFarbe(String farbe) {
        this.farbe = farbe;  // Kein Dollar, nur Punkt
    }
}

Pass-by-Value: Was wird übergeben?

Java ist immer Pass-by-Value — aber was bedeutet das?

Bei Primitiven: Der Wert wird kopiert.

void verdoppeln(int x) {
    x = x * 2;  // Ändert nur die lokale Kopie!
}

int zahl = 5;
verdoppeln(zahl);
System.out.println(zahl);  // Immer noch 5!

Bei Objekten: Die Referenz wird kopiert (nicht das Objekt!).

void lackieren(Auto auto) {
    auto.farbe = "Gold";  // Ändert das ECHTE Objekt!
}

Auto meinAuto = new Auto();
meinAuto.farbe = "Rot";
lackieren(meinAuto);
System.out.println(meinAuto.farbe);  // Gold!

Aber: Du kannst die Referenz nicht austauschen:

void ersetzen(Auto auto) {
    auto = new Auto();  // Lokale Referenz wird ersetzt
    auto.farbe = "Lila";
}

Auto meinAuto = new Auto();
meinAuto.farbe = "Rot";
ersetzen(meinAuto);
System.out.println(meinAuto.farbe);  // Immer noch Rot!

Lombok — Getter/Setter automatisch generieren

Ohne Lombok:

public class Auto {
    private String farbe;
    private int ps;
    private String marke;
    
    public String getFarbe() { return farbe; }
    public void setFarbe(String farbe) { this.farbe = farbe; }
    public int getPs() { return ps; }
    public void setPs(int ps) { this.ps = ps; }
    public String getMarke() { return marke; }
    public void setMarke(String marke) { this.marke = marke; }
    // ... 30+ Zeilen für nichts 😴
}

Mit Lombok:

import lombok.Getter;
import lombok.Setter;

@Getter @Setter
public class Auto {
    private String farbe;
    private int ps;
    private String marke;
}
// Fertig! Lombok generiert alle Getter und Setter.

Noch kürzer mit @Data:

import lombok.Data;

@Data  // Generiert: Getter, Setter, toString, equals, hashCode
public class Auto {
    private String farbe;
    private int ps;
    private String marke;
}

Maven-Dependency:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

---

🔵 BONUS

Für Wissbegierige: Varargs, Method Chaining und mehr.

Varargs — Variable Anzahl von Argumenten

Manchmal weißt du nicht, wie viele Argumente kommen:

void druckeAlle(String... texte) {  // ... = Varargs
    for (String text : texte) {
        System.out.println(text);
    }
}

druckeAlle("Eins");
druckeAlle("Eins", "Zwei");
druckeAlle("Eins", "Zwei", "Drei", "Vier", "Fünf");

Regeln für Varargs:

• Nur EIN Varargs-Parameter pro Methode
• Muss der LETZTE Parameter sein
• Wird intern als Array behandelt

Method Chaining — Fluent Interface

Wenn Setter this zurückgeben, kannst du Aufrufe verketten:

public class Auto {
    private String farbe;
    private int ps;
    
    public Auto setFarbe(String farbe) {
        this.farbe = farbe;
        return this;  // Gibt sich selbst zurück
    }
    
    public Auto setPs(int ps) {
        this.ps = ps;
        return this;
    }
}

// Fluent Interface:
Auto auto = new Auto()
    .setFarbe("Rot")
    .setPs(150);

Mit Lombok noch einfacher:

@Setter
@Accessors(chain = true)  // Aktiviert Method Chaining
public class Auto {
    private String farbe;
    private int ps;
}

Wann Methoden aufteilen?

Faustregel: Eine Methode sollte eine Sache tun.

// ❌ Zu viel in einer Methode
void verarbeiteBestellung(Bestellung b) {
    // Validierung
    // Preis berechnen
    // Lagerbestand prüfen
    // E-Mail senden
    // Datenbank speichern
    // Log schreiben
    // ... 200 Zeilen
}

// ✅ Aufgeteilt
void verarbeiteBestellung(Bestellung b) {
    validieren(b);
    double preis = berechnePreis(b);
    pruefeVerfuegbarkeit(b);
    speichern(b);
    benachrichtigen(b);
}

---

💬 Real Talk

Tom fragt, Nova erklärt — Fragen, die sich jeder stellt.

Java Fleet Büro, 11:00 Uhr. Tom starrt auf seinen Bildschirm, Nova kommt mit Kaffee vorbei.

---

Tom: Nova, ich check das mit this nicht. Warum schreibt man this.farbe = farbe? Das sieht aus wie farbe = farbe!

Nova: setzt sich Okay, pass auf. Der Parameter heißt farbe. Das Attribut heißt auch farbe. Ohne this weiß Java nicht, welches du meinst — und nimmt dann immer das „nächste“, also den Parameter.

Tom: Also ohne this würde ich den Parameter auf sich selbst setzen?

Nova: Exakt! farbe = farbe macht: „Nimm den Parameter und… weise ihn dem Parameter zu.“ Das Attribut bleibt unverändert. Mit this.farbe sagst du explizit: „Das Attribut von DIESEM Objekt.“

Tom: Aaaah! tippt Und wenn die Namen unterschiedlich wären?

Nova: Dann bräuchtest du this nicht. Aber die Konvention ist: Parameter und Attribut heißen gleich. Ist lesbarer. Und this macht’s eindeutig.

Tom: Okay… und Methodenüberladung — ist das nicht verwirrend? Drei Methoden mit gleichem Namen?

Nova: lacht Am Anfang schon! Aber denk an System.out.println(). Die kannst du mit int, String, double, egal was aufrufen. Das sind alles überladene Versionen!

Tom: Oh! Das hab ich nie hinterfragt…

Nova: Siehst du. Du benutzt es schon die ganze Zeit. Jetzt weißt du nur, wie’s funktioniert. 😊

Tom: Nice. Eine letzte Frage: Wann void und wann Rückgabetyp?

Nova: Easy: Wenn die Methode nur was TUT (drucken, speichern, ändern) → void. Wenn du einen Wert BRAUCHST (berechnen, suchen, prüfen) → Rückgabetyp. Stell dir vor: „Brauche ich das Ergebnis?“ Ja → Rückgabe. Nein → void.

Tom: Das ist eigentlich logisch. Danke, Nova!

Nova: steht auf Kein Ding. Und denk dran: Lokale Variablen initialisieren! Sonst meckert der Compiler.

---

✅ Checkpoint: Hast du es verstanden?

Quiz

Beantworte diese Fragen ohne nachzuschauen. Die Lösungen findest du weiter unten.

Frage 1: Was ist der Unterschied zwischen einer Instanzvariablen und einer lokalen Variablen?

Frage 2: Was bedeutet void bei einer Methode?

Frage 3: Wofür brauchst du die this-Referenz?

Frage 4: Was ist Methodenüberladung?

Frage 5: Du hast folgenden Code:

void setPs(int ps) {
    ps = ps;
}

Was ist das Problem, und wie fixst du es?

---

Mini-Challenge

Aufgabe: Erweitere die Auto-Klasse um folgende Funktionen:

1. Attribut: kilometerstand (int) — startet bei 0
2. Methode: fahren(int km) — erhöht den Kilometerstand und gibt eine Nachricht aus
3. Methode: fahren(int km, String ziel) — wie oben, aber mit Zielangabe
4. Methode: getKilometerstand() — gibt den aktuellen Stand zurück
5. Methode: tanken(double liter) — gibt „Getankt: X Liter“ aus

Bonus: Füge ein Attribut tankinhalt hinzu und prüfe in fahren(), ob genug Benzin da ist.

Lösung:
Die Lösung zu dieser Challenge findest du am Anfang von Tag 3 als Kurzwiederholung! 🚀

---

❓ FAQ — Häufig gestellte Fragen

Frage 1: Muss ich immer this schreiben?

Nein! Nur wenn Parameter und Attribut gleich heißen. Sonst ist this optional. Manche schreiben es trotzdem für Klarheit.

---

Frage 2: Kann eine Methode mehrere Werte zurückgeben?

Nicht direkt. Aber du kannst:

• Ein Array zurückgeben
• Ein Objekt zurückgeben (mit mehreren Attributen)
• Ab Java 16: Records verwenden

// Mit Record (Java 16+):
record Ergebnis(int wert1, int wert2) {}

Ergebnis berechne() {
    return new Ergebnis(10, 20);
}

---

Frage 3: Was passiert, wenn ich eine lokale Variable nicht initialisiere?

Compilerfehler! Anders als Instanzvariablen haben lokale Variablen keine Default-Werte.

void test() {
    int x;
    System.out.println(x);  // ❌ Fehler: Variable x might not have been initialized
}

---

Frage 4: Kann ich Methoden in Methoden definieren?

Nicht direkt (keine verschachtelten Methoden wie in Python). Aber ab Java 8 gibt es Lambdas, die ähnlich funktionieren.

---

Frage 5: Was ist der Unterschied zwischen Parameter und Argument?

• Parameter: Der Platzhalter in der Methodendefinition → void fahren(int km)
• Argument: Der echte Wert beim Aufruf → auto.fahren(100)

Merkhilfe: Parameter = Platzhalter, Argument = Aktueller Wert.

---

Frage 6: Wie viele Parameter sollte eine Methode maximal haben?

Faustregel: 3-4 maximal. Mehr wird unübersichtlich. Bei vielen Parametern → Objekt übergeben oder Builder-Pattern nutzen.

---

Frage 7: Bernd hat mal gesagt, Getter und Setter seien „ceremony without meaning“. Was meint er?

lacht Klassischer Bernd. Er meint: Wenn dein Getter nur return farbe macht und dein Setter nur this.farbe = farbe, dann ist das Boilerplate ohne echten Nutzen.

Real talk: Er hat nicht ganz unrecht. Aber Getter/Setter ermöglichen später Validierung, Logging, Lazy Loading. Außerdem: Lombok macht’s ja einfach. Bernd ist halt… Bernd. Lowkey ein Purist. 🤷

---

📚 Quiz-Lösungen

Hier sind die Antworten zum Quiz von oben:

---

Frage 1: Was ist der Unterschied zwischen einer Instanzvariablen und einer lokalen Variablen?

Antwort:

• Instanzvariable: Deklariert in der Klasse (außerhalb von Methoden), gehört zum Objekt, hat Default-Werte, lebt so lange wie das Objekt.
• Lokale Variable: Deklariert innerhalb einer Methode, existiert nur während des Methodenaufrufs, hat KEINE Default-Werte (muss initialisiert werden).

---

Frage 2: Was bedeutet void bei einer Methode?

Antwort:

void bedeutet, dass die Methode keinen Wert zurückgibt. Sie tut etwas (z.B. drucken, speichern), aber der Aufrufer bekommt kein Ergebnis zurück.

void fahren() {           // Gibt nichts zurück
    System.out.println("Fahre!");
}

int getPs() {             // Gibt int zurück
    return 150;
}

---

Frage 3: Wofür brauchst du die this-Referenz?

Antwort:

this ist eine Referenz auf das aktuelle Objekt. Du brauchst es:

1. Wenn Parameter und Attribut gleich heißen: this.farbe = farbe;
2. Um das eigene Objekt weiterzugeben: garage.aufnehmen(this);
3. Um Klarheit zu schaffen, welches Attribut gemeint ist

---

Frage 4: Was ist Methodenüberladung?

Antwort:

Methodenüberladung (Overloading) bedeutet: Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern.

Java wählt automatisch die richtige Version basierend auf den übergebenen Argumenten.

void fahren() { }                    // Version 1
void fahren(int km) { }              // Version 2
void fahren(int km, String ziel) { } // Version 3

---

Frage 5: Was ist das Problem und wie fixst du es?

void setPs(int ps) {
    ps = ps;  // PROBLEM!
}

Antwort:

Der Parameter ps wird auf sich selbst gesetzt — das Attribut bleibt unverändert!

Fix:

void setPs(int ps) {
    this.ps = ps;  // this.ps = Attribut, ps = Parameter
}

---

🎉 Tag 2 geschafft!

Du hast es geschafft! 🚀

Das hast du heute gelernt:

• ✅ Instanzvariablen vs. lokale Variablen — der wichtige Unterschied
• ✅ Methoden mit Parametern und Rückgabewerten
• ✅ this — die Referenz auf das aktuelle Objekt
• ✅ Methodenüberladung — gleicher Name, unterschiedliche Parameter

Egal ob du heute zum ersten Mal this verstanden hast oder nur die Java-Syntax auffrischen wolltest — du bist weiter gekommen. No cap.

---

🔮 Wie geht’s weiter?

Morgen in Tag 3: Datenkapselung & Sichtbarkeit

Heute konntest du auto.farbe = "Rot" direkt setzen. Aber was, wenn jemand auto.ps = -500 setzt? Oder auto.farbe = null?

Morgen lernst du:

• Warum Attribute private sein sollten
• Wie Getter und Setter schützen
• Was public, private, protected bedeuten

Das wird wichtig — versprochen! 🎯

---

📦 Downloads

Starter-Projekt für Tag 2:

⬇️ Tag02_Attribute_Methoden.zip — Komplettes Maven-Projekt

Inhalt:

Tag02_Attribute_Methoden/
├── pom.xml
├── README.md
└── src/main/java/
    └── de/javafleet/oop/
        ├── Main.java
        └── model/
            └── Auto.java

Quick Start:

cd Tag02_Attribute_Methoden
mvn compile
mvn exec:java

🔧 Troubleshooting

Problem: „Variable might not have been initialized“

error: variable x might not have been initialized

Lösung: Lokale Variablen haben keine Default-Werte. Initialisiere sie:

int x;           // ❌ Nicht initialisiert
int x = 0;       // ✅ Initialisiert

---

Problem: Methode wird nicht gefunden (bei Überladung)

error: method fahren(String, int) does not exist

Lösung: Die Reihenfolge der Parameter muss stimmen! fahren(int, String) ist nicht dasselbe wie fahren(String, int).

---

Problem: „non-static method cannot be referenced from static context“

error: non-static method fahren() cannot be referenced from a static context

Lösung: Du versuchst, eine Objektmethode ohne Objekt aufzurufen:

// ❌ Falsch:
Auto.fahren();

// ✅ Richtig:
Auto meinAuto = new Auto();
meinAuto.fahren();

---

🔗 Resources & Links

🟢 Für Einsteiger

Ressource	Beschreibung	Sprache
Oracle — Defining Methods	Offizielle Doku zu Methoden	🇬🇧
W3Schools — Java Methods	Einfache Erklärungen	🇬🇧
Java ist auch eine Insel — Methoden	Kostenloses Buch (Deutsch)	🇩🇪

🟡 Für Fortgeschrittene

Ressource	Beschreibung	Sprache
Baeldung — Method Overloading	Überladung vs. Überschreibung	🇬🇧
Baeldung — Pass-by-Value	Wie Java Parameter übergibt	🇬🇧
Lombok Dokumentation	Alle Lombok-Features	🇬🇧

🛠️ Tools

Tool	Beschreibung	Link
Lombok	Boilerplate-Code reduzieren	projectlombok.org
IntelliJ IDEA	Generiert Getter/Setter automatisch	jetbrains.com/idea

---

💬 Feedback

Fragen? Schreib mir:

• Nova: nova.trent@java-developer.online

Feedback zum Kurs? Nutze den 👎-Button unten — das hilft uns, besser zu werden!

---

👋 Bis morgen!

Hey, Tag 2 ist durch. Du weißt jetzt, wie Attribute und Methoden zusammenspielen.

Morgen wird’s richtig wichtig: Datenkapselung. Warum sollte niemand direkt auf deine Attribute zugreifen können? Und wie schützt du sie?

Mach erstmal Pause. Lass das sacken. Und dann: See you tomorrow! 🚀

---

Nova Trent
Junior Entwicklerin bei Java Fleet Systems Consulting
„Jetzt weiß ich, was this bedeutet!“ 😄

---

Tags: #Java #OOP #Methoden #Attribute #this #Überladung #Tutorial

© 2025 Java Fleet Systems Consulting | java-developer.online