Tag 1 : Java OOP-Konzepte

Von Nova Trent, Junior Entwicklerin bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Einsteiger
Lesezeit: 25–30 Minuten
Voraussetzungen: Java Grundlagen abgeschlossen (Variablen, Datentypen, Kontrollstrukturen, Arrays)

📋 Kursübersicht: Java OOP in 10 Tagen

Tag	Thema	Status
→ 1	OOP-Konzepte & erste Klasse	📍 Du bist hier
2	Attribute & Methoden	⏳
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: Java Grundlagen abgeschlossen (Kurs 1)
Folgekurs: Erweiterte Techniken (Kurs 3)

⚡ Das Wichtigste in 30 Sekunden

Dein Problem: Du kannst Java-Code schreiben, aber alles landet in einer riesigen main-Methode. Das wird schnell unübersichtlich.

Die Lösung: Objektorientierte Programmierung (OOP) — du strukturierst deinen Code in Klassen und Objekte.

Heute lernst du:

✅ Was OOP überhaupt ist und warum es dein Leben einfacher macht
✅ Was Klassen und Objekte sind (Bauplan vs. fertiges Haus)
✅ Wie du deine erste eigene Klasse schreibst
✅ Wie du Objekte mit new erzeugst
✅ Was Pakete sind und warum du sie brauchst

Für wen ist dieser Artikel?

🌱 OOP-Neulinge: Du lernst das Konzept von Grund auf
🌿 OOP-Umsteiger: Du siehst, wie Java das macht (vs. Python, C#, etc.)
🌳 Profis: Im Bonus findest du Design-Überlegungen

Zeit-Investment: 25–30 Minuten

👋 Nova: „Endlich macht Code Sinn!“

Hi! 👋

Nova hier.

Okay, real talk: Als ich in der Uni das erste Mal „Objektorientierung“ gehört habe, dachte ich: „Häh?! Was soll das sein — Objekte? Klassen? Klingt nach Philosophie, nicht nach Programmieren.“

Ich hatte vorher nur prozedural programmiert. Eine main-Methode, ein paar Funktionen, fertig. Hat funktioniert — bis mein Code 500 Zeilen hatte und ich nicht mehr wusste, welche Variable was macht. 😅

Dann kam OOP. Und honestly? Es hat klick gemacht.

Plötzlich konnte ich meinen Code in logische Einheiten aufteilen. Ein Auto hat Eigenschaften (Farbe, PS) und kann Dinge tun (fahren, bremsen). Das ist so viel intuitiver als 47 lose Variablen!

Heute zeige ich dir genau das, was mir damals geholfen hat. Schritt für Schritt. Keine Theorie-Wüste, sondern echte Aha-Momente.

Bist du ready? Let’s go! 🚀

🟢 GRUNDLAGEN

Was ist Objektorientierte Programmierung?

Kurz gesagt: OOP ist eine Art, Code zu organisieren — indem du die echte Welt nachahmst.

In der echten Welt gibt es Dinge (Objekte):

Ein Auto hat eine Farbe und kann fahren
Ein Hund hat einen Namen und kann bellen
Ein Bankkonto hat einen Kontostand und kann Geld überweisen

In OOP bilden wir genau das ab:

Echte Welt          →    Java-Code
─────────────────────────────────────
Auto (Ding)         →    Objekt
Bauplan für Autos   →    Klasse
Farbe, PS           →    Attribute (Eigenschaften)
fahren, bremsen     →    Methoden (Verhalten)

Warum OOP? Was ist der Vorteil?

Ohne OOP (prozedural):

// Alles in einer Methode — wird schnell chaotisch
String auto1Farbe = "Rot";
int auto1PS = 150;
String auto2Farbe = "Blau";
int auto2PS = 200;

// 50 Zeilen später...
// Welches Auto war nochmal welches? 😵

Mit OOP:

// Jedes Auto ist ein eigenständiges Objekt
Auto meinAuto = new Auto("Rot", 150);
Auto deinAuto = new Auto("Blau", 200);

meinAuto.fahren();  // Klar, welches Auto fährt

Die Vorteile auf einen Blick:

Ohne OOP	Mit OOP
Variablen fliegen lose herum	Daten gehören zum Objekt
Code schwer wiederverwendbar	Klassen sind Baupläne — einmal schreiben, oft nutzen
Änderungen = Chaos	Änderungen an einer Stelle
Schwer zu testen	Objekte einzeln testbar

Klasse vs. Objekt — Der wichtigste Unterschied

Das ist DER Kern von OOP. Wenn du das verstehst, hast du 50% geschafft.

Klasse = Bauplan

Beschreibt, WIE etwas aussieht
Existiert nur einmal im Code
Erzeugt nichts von alleine

Objekt = Fertiges Haus

Ist eine konkrete Instanz nach dem Bauplan
Kann beliebig oft erzeugt werden
Hat echte Werte (Farbe: „Rot“, PS: 150)

Abbildung 1: Eine Klasse ist der Bauplan (links), Objekte sind konkrete Instanzen mit echten Werten (rechts). Mit new erzeugst du beliebig viele Objekte aus einem Bauplan.

Deine erste Klasse schreiben

Jetzt wird’s praktisch! Wir schreiben eine einfache Auto-Klasse.

Schritt 1: Die Klasse definieren

public class Auto {
    // Hier kommt der Inhalt
}

Das war’s schon für den Anfang! Eine leere Klasse. Aber sie existiert.

Schritt 2: Attribute hinzufügen (Eigenschaften)

public class Auto {
    // Attribute — Was HAT ein Auto?
    String farbe;
    int ps;
    String marke;
}

Schritt 3: Methoden hinzufügen (Verhalten)

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

Fertig! Das ist deine erste Klasse. 🎉

Objekte erzeugen mit `new`

Die Klasse alleine macht noch nichts. Du brauchst Objekte — konkrete Autos nach deinem Bauplan.

public class Main {
    public static void main(String[] args) {
        // Objekt erzeugen mit "new"
        Auto meinAuto = new Auto();
        
        // Attribute setzen
        meinAuto.farbe = "Rot";
        meinAuto.ps = 150;
        meinAuto.marke = "VW";
        
        // Methode aufrufen
        meinAuto.fahren();  // Ausgabe: Das Auto fährt!
        
        // Noch ein Objekt — komplett unabhängig!
        Auto deinAuto = new Auto();
        deinAuto.farbe = "Blau";
        deinAuto.ps = 200;
        deinAuto.marke = "BMW";
    }
}

Was passiert hier genau?

Auto meinAuto = new Auto();
│     │         │    │
│     │         │    └── Konstruktor aufrufen (dazu später mehr)
│     │         └─────── Neues Objekt im Speicher anlegen
│     └───────────────── Variablenname (Referenz auf das Objekt)
└─────────────────────── Typ (welche Klasse?)

Pakete (Packages) — Ordnung muss sein

Stell dir vor, du hast 100 Klassen. Alle in einem Ordner. Chaos!

Pakete sind wie Ordner für deine Klassen:

src/
├── de/javafleet/fahrzeuge/
│   ├── Auto.java
│   ├── Motorrad.java
│   └── Fahrrad.java
├── de/javafleet/personen/
│   ├── Fahrer.java
│   └── Kunde.java
└── de/javafleet/utils/
    └── Helper.java

So deklarierst du ein Paket:

// Muss die ERSTE Zeile in der Datei sein!
package de.javafleet.fahrzeuge;

public class Auto {
    // ...
}

Klassen aus anderen Paketen importieren:

package de.javafleet.main;

// Import der Auto-Klasse aus anderem Paket
import de.javafleet.fahrzeuge.Auto;

public class Main {
    public static void main(String[] args) {
        Auto meinAuto = new Auto();  // Jetzt verfügbar!
    }
}

Paket-Namenskonvention:

Kleinbuchstaben
Domain rückwärts: de.javafleet.projekt
Keine Bindestriche, keine Sonderzeichen

🟡 PROFESSIONALS

Schon OOP-Erfahrung aus C#, C++ oder PHP? Hier sind die Java-Besonderheiten — ohne Grundlagen-Wiederholung.

Für C#-Umsteiger: Fast wie zuhause

Gute Nachricht: Java und C# sind Geschwister. Vieles funktioniert gleich.

Was du schon kennst:

C#	Java	Unterschied?
`class Auto { }`	`class Auto { }`	✅ Identisch
`new Auto()`	`new Auto()`	✅ Identisch
`public`, `private`	`public`, `private`	✅ Identisch
`namespace`	`package`	⚠️ Syntax anders
`using`	`import`	⚠️ Syntax anders
Properties (`get; set;`)	Getter/Setter manuell	❌ Kein Auto-Property!

Die größten Stolperfallen:

// C# — Properties sind eingebaut
public class Auto {
    public string Farbe { get; set; }  // ✅ C# Auto-Property
}

// Java — Du musst Getter/Setter selbst schreiben
public class Auto {
    private String farbe;              // Attribut
    
    public String getFarbe() {         // Getter
        return farbe;
    }
    
    public void setFarbe(String farbe) {  // Setter
        this.farbe = farbe;
    }
}

Weitere Unterschiede:

Thema	C#	Java
Namenskonvention	`PascalCase` für alles	`camelCase` für Methoden/Variablen
String-Vergleich	`==` funktioniert	`==` vergleicht Referenzen! → `.equals()`
Nullable Types	`int?`	`Integer` (Wrapper-Klasse)
`var` Keyword	Überall	Nur lokale Variablen (ab Java 10)
Partielle Klassen	`partial class`	❌ Gibt’s nicht

Der häufigste Fehler von C#-Umsteigern:

String a = "Hallo";
String b = "Hallo";

if (a == b) { }        // ⚠️ GEFÄHRLICH! Vergleicht Referenzen
if (a.equals(b)) { }   // ✅ RICHTIG! Vergleicht Inhalt

Für C++-Umsteiger: Weniger Kontrolle, mehr Sicherheit

Java nimmt dir Arbeit ab — aber auch Kontrolle.

Was du schon kennst (aber anders funktioniert):

C++	Java	Was ist anders?
`class Auto { };`	`class Auto { }`	Kein Semikolon am Ende
`Auto* meinAuto = new Auto();`	`Auto meinAuto = new Auto();`	Keine Pointer-Syntax
`delete meinAuto;`	—	❌ Kein `delete`! Garbage Collector
Header + Implementation	Alles in `.java`	❌ Keine `.h`-Dateien
Mehrfachvererbung	Nur Interfaces	❌ `class A : B, C` geht nicht

Das Wichtigste: Kein manuelles Speichermanagement!

// C++ — Du bist verantwortlich
Auto* meinAuto = new Auto();
// ... viel Code ...
delete meinAuto;  // Vergessen = Memory Leak!

// Java — Garbage Collector räumt auf
Auto meinAuto = new Auto();
// ... viel Code ...
// Kein delete nötig! GC macht das automatisch.

Mehrfachvererbung — Java’s Lösung:

// C++ — Mehrfachvererbung möglich
class Amphibienfahrzeug : public Auto, public Boot { };

// Java — Nur EINE Klasse, aber MEHRERE Interfaces
public class Amphibienfahrzeug extends Auto implements Schwimmfaehig {
    // Auto = Basisklasse (nur eine!)
    // Schwimmfaehig = Interface (beliebig viele)
}

Weitere Unterschiede:

Thema	C++	Java
Pointer	`Auto* ptr`	❌ Keine Pointer (nur Referenzen)
Referenzen	`Auto& ref`	Alles ist Referenz (außer Primitive)
Destruktor	`~Auto()`	❌ Kein Destruktor (nur `finalize()`, deprecated)
Operator Overloading	`+`, `-`, `==` überladen	❌ Nicht möglich (außer `String +`)
Templates	`template<typename T>`	Generics `<T>` (Type Erasure!)
Const-Correctness	`const` überall	`final` (aber weniger mächtig)

Was C++-Entwickler vermissen werden:

Deterministische Destruktion (RAII) → In Java: try-with-resources
Operator Overloading → Du schreibst .add() statt +
Stack-Allokation von Objekten → Alles auf dem Heap

Für PHP-Umsteiger: Willkommen in der typisierten Welt

PHP 8 hat viel von Java übernommen. Aber Java war zuerst da — und ist strenger.

Was du schon kennst:

PHP	Java	Unterschied?
`class Auto { }`	`class Auto { }`	✅ Ähnlich
`new Auto()`	`new Auto()`	✅ Identisch
`$this->farbe`	`this.farbe`	⚠️ Kein `$`, Punkt statt `->`
`public function`	`public void`	⚠️ Rückgabetyp PFLICHT
`namespace App\Models`	`package app.models`	⚠️ Andere Syntax

Der größte Unterschied: Statische Typisierung

// PHP — Typ optional (oder Type Hints)
class Auto {
    public $farbe;  // Kann alles sein
    
    public function setFarbe($farbe) {
        $this->farbe = $farbe;
    }
}

$auto = new Auto();
$auto->farbe = "Rot";
$auto->farbe = 123;      // ✅ PHP erlaubt das
$auto->farbe = ['a'];    // ✅ PHP erlaubt auch das

// Java — Typ ist PFLICHT
public class Auto {
    private String farbe;  // NUR Strings!
    
    public void setFarbe(String farbe) {
        this.farbe = farbe;
    }
}

Auto auto = new Auto();
auto.setFarbe("Rot");    // ✅ OK
auto.setFarbe(123);      // ❌ COMPILERFEHLER!

Weitere Unterschiede:

Thema	PHP	Java
Variablen-Prefix	`$variable`	`variable` (kein $)
Array-Syntax	`$arr = [1, 2, 3]`	`int[] arr = {1, 2, 3}`
Assoziative Arrays	`['key' => 'value']`	`Map<String, String>`
Traits	`use MyTrait;`	❌ Keine Traits (Interfaces + Default Methods)
Magic Methods	`__construct`, `__toString`	Konstruktor, `toString()`
Sichtbarkeit Default	`public`	`package-private` (ohne Modifier)

Was PHP-Entwickler überrascht:

// Kein $ vor Variablen!
String farbe = "Rot";     // ✅ Richtig
String $farbe = "Rot";    // ❌ Syntaxfehler

// Semikolon ist IMMER Pflicht
String farbe = "Rot"      // ❌ Fehler!
String farbe = "Rot";     // ✅ Richtig

// Kein Array mit gemischten Typen
Object[] mixed = {"text", 123, true};  // Geht, aber unschön
// Besser: Generics (kommt in Kurs 3)

Für alle Umsteiger: Lombok — Dein Getter/Setter-Retter

Du kommst aus C# und vermisst Properties? Oder du hasst einfach Boilerplate-Code?

Lombok ist eine Bibliothek, die dir das Leben erleichtert:

// OHNE Lombok — 30 Zeilen für nichts
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; }
    // ... und so weiter 😴
}

// MIT Lombok — 5 Zeilen, fertig!
import lombok.Data;

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

Die wichtigsten Lombok-Annotations:

Annotation	Generiert	C#-Äquivalent
`@Getter`	Getter für alle Felder	`{ get; }`
`@Setter`	Setter für alle Felder	`{ set; }`
`@Data`	Getter + Setter + toString + equals + hashCode	Fast wie Record
`@NoArgsConstructor`	Leerer Konstruktor	—
`@AllArgsConstructor`	Konstruktor mit allen Feldern	—
`@Builder`	Builder-Pattern	—

Einrichtung (Maven):

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

IDE-Plugin nicht vergessen!

IntelliJ: Settings → Plugins → „Lombok“ installieren
VS Code: Extension „Lombok Annotations Support“
Eclipse: Lombok-JAR ausführen

⚠️ Hinweis: Lombok ist NICHT Teil von Standard-Java. Es ist eine externe Bibliothek. In diesem Kurs zeigen wir erstmal die Standard-Variante — aber in echten Projekten ist Lombok quasi Standard.

Für alle Umsteiger: Java’s Eigenheiten

1. Eine Datei = Eine public Klasse

// Auto.java
public class Auto { }     // ✅ OK — Name = Dateiname
class Motor { }           // ✅ OK — package-private
public class Reifen { }   // ❌ FEHLER! Nur EINE public Klasse

2. Alles erbt von Object

public class Auto { }  
// Ist eigentlich:
public class Auto extends Object { }

// Deshalb hat JEDE Klasse diese Methoden:
meinAuto.toString();    // Von Object geerbt
meinAuto.equals(x);     // Von Object geerbt
meinAuto.hashCode();    // Von Object geerbt

3. Packages ≠ Namespaces ≠ Directories (aber fast)

Die Ordnerstruktur MUSS zum Package passen:

package de.javafleet.model;  →  src/de/javafleet/model/Auto.java

Best Practices für Klassennamen

✅ Richtig	❌ Falsch	Warum?
`Auto`	`auto`	Klassen = PascalCase
`BankKonto`	`bankKonto`	Klassen beginnen groß
`HttpRequest`	`HTTPRequest`	Nur erster Buchstabe von Akronymen groß
`getFarbe()`	`GetFarbe()`	Methoden = camelCase (nicht wie C#!)

Packages in der Praxis

Typische Projektstruktur:

src/main/java/
├── de/firma/projekt/
│   ├── model/           ← Datenklassen (Auto, Person, ...)
│   ├── service/         ← Geschäftslogik
│   ├── controller/      ← Steuerung (z.B. für Web)
│   ├── repository/      ← Datenbankzugriff
│   └── util/            ← Hilfsfunktionen

Import-Tipps:

// Einzelne Klasse importieren (empfohlen)
import de.javafleet.model.Auto;

// Alle Klassen aus einem Paket (okay, aber ungenauer)
import de.javafleet.model.*;

// NIEMALS: Standardbibliothek mit * importieren
import java.util.*;  // Geht, aber welche Klassen nutzt du wirklich?

🔵 BONUS

Für Wissbegierige: Design-Überlegungen und Ausblick.

Wann ist etwas eine Klasse?

Faustregeln:

Hat es einen Namen? → Wahrscheinlich eine Klasse
- Auto ✅, Person ✅, Bestellung ✅
Hat es Eigenschaften UND Verhalten? → Definitiv eine Klasse
- Ein Auto HAT eine Farbe und KANN fahren
Gibt es mehrere davon? → Klasse mit Objekten
- Ein Auto, noch ein Auto, noch eins…
Ist es nur ein Wert? → Wahrscheinlich ein Attribut
- „Rot“ ist keine Klasse, sondern ein Wert von farbe

Objekte im Speicher — Was passiert bei `new`?

Auto meinAuto = new Auto();

Im Hintergrund:

Abbildung 2: Der Stack speichert die Referenz (Adresse), der Heap speichert das echte Objekt mit allen Attributen.

Wichtig: meinAuto ist nicht das Objekt selbst, sondern eine Referenz (Adresse) auf das Objekt im Heap.

Ausblick: Was kommt noch?

In den nächsten Tagen lernst du:

Tag	Thema	Warum wichtig?
2	Attribute & Methoden	Objekte mit Leben füllen
3	Datenkapselung	Daten schützen
4	Konstruktoren	Objekte richtig initialisieren
5	Static & Konstanten	Klassenvariablen verstehen

💬 Real Talk

Tom fragt, Nova erklärt — Die Fragen, die sich jeder stellt, aber keiner laut sagt.

Java Fleet Küche, 14:30 Uhr. Tom sitzt mit seinem Laptop am Tisch, Nova holt sich einen Kaffee.

Tom: Nova, ich hab eine dumme Frage…

Nova: setzt sich Es gibt keine dummen Fragen, Tom. Nur dumme Antworten. Was hast du?

Tom: Warum heißt das „objektorientiert“? Wir schreiben doch die ganze Zeit Klassen, nicht Objekte?

Nova: Oh Mann, das hab ich mich am Anfang auch gefragt! lacht Der Name kommt daher, dass wir in Objekten denken. Die Klasse ist nur der Bauplan — das Objekt ist das Ding, mit dem du wirklich arbeitest. Du fährst ja auch nicht mit einem Bauplan zur Uni, sondern mit einem echten Auto. Oder Bus. Oder Fahrrad. Was auch immer.

Tom: Okay, das ergibt Sinn… Aber warum schreibe ich Auto meinAuto = new Auto()? Warum zweimal Auto?

Nova: Gute Frage! tippt auf seinen Bildschirm Links steht der Typ — Java muss wissen, was für eine Art Referenz das ist. Rechts steht der Konstruktor — welches Objekt tatsächlich erzeugt wird. Heute sieht das identisch aus, aber bei Vererbung kann das unterschiedlich sein.

Tom: Häh?! Vererbung?

Nova: grinst Kommt in Tag 6. Für jetzt: Links = „Was erwartest du?“, Rechts = „Was bekommst du?“. Merk dir das einfach.

Tom: Okay… scrollt Noch was: Packages. Warum nicht einfach alles in einen Ordner?

Nova: Kannst du machen. Bei 10 Klassen. Bei unserem Kundenprojekt haben wir 500+ Klassen. Ohne Packages würdest du drei Stunden nach UserController suchen. Real talk: Struktur rettet dir den Arsch. Außerdem vermeiden Packages Namenskonflikte — du könntest de.javafleet.model.User und com.kunde.model.User haben, kein Problem.

Tom: Das klingt logisch. tippt Ich glaub, ich hab’s verstanden.

Nova: steht auf Siehst du? Keine dummen Fragen. Ich hab Elyndra am Anfang viel dümmere Sachen gefragt. zwinkert Wenn du hängst, frag einfach. Dafür bin ich da.

Tom: Danke, Nova!

Nova: geht zur Tür Achja — und gewöhn dir ab, Klassennamen klein zu schreiben. Ich hab dein auto im Commit gesehen. PascalCase, Tom. Immer PascalCase.

Tom: wird rot …ups.

✅ 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 Klasse und einem Objekt?

Frage 2: Was macht der new-Operator?

Frage 3: Wie viele public Klassen darf eine .java-Datei enthalten?

Frage 4: Was muss die ERSTE Zeile einer Java-Datei sein, wenn du ein Paket verwendest?

Frage 5: Du hast diese Klasse:

public class Hund {
    String name;
    void bellen() {
        System.out.println("Wuff!");
    }
}

Wie erzeugst du ein Hund-Objekt und rufst bellen() auf?

Mini-Challenge

Aufgabe: Erstelle eine Klasse Buch mit folgenden Anforderungen:

Die Klasse soll im Paket de.deinname.bibliothek liegen
Attribute: titel (String), autor (String), seiten (int)
Methode: info() — gibt „Titel von Autor (X Seiten)“ aus
Erstelle in einer Main-Klasse zwei Buch-Objekte und rufe info() auf

Hinweise:

Erstelle die richtige Ordnerstruktur
Vergiss den Import nicht!
Teste deinen Code

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

❓ FAQ — Häufig gestellte Fragen

Frage 1: Muss ich für jede kleine Sache eine Klasse erstellen?

Nein! Nicht alles muss eine Klasse sein. Einfache Berechnungen oder kurze Scripte können prozedural bleiben. OOP lohnt sich, wenn:

Du mehrere Instanzen brauchst (mehrere Autos, mehrere Benutzer)
Dein Code wächst und Struktur braucht
Du Code wiederverwenden willst

Frage 2: Was ist der Unterschied zwischen public class und class?

public class — Von überall aus sichtbar, auch aus anderen Paketen
class (ohne public) — Nur im gleichen Paket sichtbar (package-private)

public class Auto { }     // Überall verwendbar
class Motor { }           // Nur im gleichen Paket

Frage 3: Kann ich eine Klasse in einer anderen Klasse haben?

Ja! Das nennt sich „innere Klasse“ (Inner Class). Aber das ist Stoff für später (Kurs 3). Für jetzt: Eine Klasse pro Datei, und du bist safe.

Frage 4: Warum main in einer separaten Klasse?

Muss nicht, aber ist Best Practice. Die main-Methode ist dein Einstiegspunkt — sie gehört nicht zur „Logik“ deiner Klassen. Trenne Einstieg von Datenmodell.

Frage 5: Warum Paketnamen mit Domain rückwärts?

Eindeutigkeit. de.javafleet.auto.Auto kollidiert nie mit com.anderefirma.auto.Auto. Die Domain gehört dir — also sind deine Pakete einzigartig.

Frage 6: Kann ich Umlaute in Klassennamen verwenden?

Technisch ja, praktisch: NEIN. Dateisysteme, Build-Tools und Teams weltweit haben damit Probleme. Bleib bei ASCII: Fahrzeug statt Fahrzëug.

Frage 7: Ich hab gehört, irgendein „Bernd“ bei Java Fleet committed Code direkt in main. Ist das wahr?

lacht Oh, du hast von Bernd gehört? Real talk: Niemand weiß, wer Bernd ist. Code erscheint einfach im Repo. Commit-Messages wie „fixed stuff“. Keine Reviews. Franz-Martin sagt, Bernd sei „schon immer da gewesen“. Manche glauben, er ist eine KI. Andere sagen, er ist ein Mythos. Ich hab ihn jedenfalls noch nie gesehen. Lowkey creepy, aber sein Code funktioniert irgendwie immer. 🤷

📚 Quiz-Lösungen

Hier sind die Antworten zum Quiz von oben:

Frage 1: Was ist der Unterschied zwischen einer Klasse und einem Objekt?

Antwort:

Eine Klasse ist ein Bauplan — sie beschreibt, welche Eigenschaften (Attribute) und welches Verhalten (Methoden) etwas hat. Ein Objekt ist eine konkrete Instanz nach diesem Bauplan — ein echtes „Ding“ im Speicher mit echten Werten.

Analogie: Klasse = Bauplan für ein Haus, Objekt = Das fertige Haus, in dem du wohnst.

Frage 2: Was macht der `new`-Operator?

Antwort:

Der new-Operator erzeugt ein neues Objekt im Speicher (auf dem Heap). Er:

Reserviert Speicherplatz für das Objekt
Ruft den Konstruktor auf (initialisiert das Objekt)
Gibt eine Referenz (Adresse) auf das Objekt zurück

Auto meinAuto = new Auto();  // Neues Auto-Objekt im Speicher

Frage 3: Wie viele `public` Klassen darf eine `.java`-Datei enthalten?

Antwort:

Genau eine. Der Name der public Klasse muss mit dem Dateinamen übereinstimmen. Du kannst weitere (nicht-public) Klassen in der gleichen Datei haben, aber nur eine darf public sein.

Frage 4: Was muss die ERSTE Zeile einer Java-Datei sein, wenn du ein Paket verwendest?

Antwort:

Die package-Deklaration:

package de.javafleet.model;  // MUSS erste Zeile sein (vor imports!)

import java.util.List;       // Imports kommen danach

public class Auto { }

Frage 5: Wie erzeugst du ein Hund-Objekt und rufst `bellen()` auf?

Antwort:

Hund meinHund = new Hund();   // Objekt erzeugen
meinHund.name = "Bello";       // Attribut setzen (optional)
meinHund.bellen();             // Methode aufrufen → Ausgabe: "Wuff!"

🎉 Tag 1 geschafft!

Du hast es geschafft! 🚀

Das hast du heute gelernt:

✅ OOP = Code organisieren wie die echte Welt
✅ Klasse = Bauplan, Objekt = fertiges Ding
✅ new erzeugt Objekte im Speicher
✅ Pakete = Ordnung für deine Klassen

Egal ob du heute zum ersten Mal „OOP“ gehört hast oder nur die Java-Syntax lernen wolltest — du bist einen großen Schritt weiter. No cap.

🔮 Wie geht’s weiter?

Morgen in Tag 2: Attribute & Methoden

Heute hast du eine Klasse mit simplen Attributen und Methoden gebaut. Aber:

Wie übergibst du Parameter an Methoden?
Was ist die this-Referenz?
Was bedeutet „Methodenüberladung“?

Das und mehr — morgen. Es wird richtig gut, versprochen! 🎯

Tipp: Mach heute die Mini-Challenge. Hands-on ist der beste Lehrer.

📦 Downloads

Starter-Projekt für Tag 1:

⬇️ Tag01_OOP_Starter.zip — Komplettes Maven-Projekt

Inhalt:

Tag01_OOP_Starter/
├── pom.xml                          # Maven-Konfiguration (Java 21)
├── README.md                        # Anleitung
└── src/main/java/
    └── de/javafleet/oop/
        ├── Main.java                # Einstiegspunkt mit Beispielen
        └── model/
            └── Auto.java            # Beispielklasse

Quick Start:

cd Tag01_OOP_Starter
mvn compile
mvn exec:java

Erwartete Ausgabe:

╔═══════════════════════════════════════╗
║   Java OOP - Tag 1: Erste Objekte     ║
╚═══════════════════════════════════════╝

>>> Mein Auto:
=== Auto-Info ===
Marke: VW
Farbe: Rot
Leistung: 150 PS
=================
Das Rote VW fährt los! 🚗
HUUUP! 📢

>>> Dein Auto:
...

✅ Tag 1 geschafft! Du hast deine ersten Objekte erstellt.

Grafiken:

⬇️ klasse-vs-objekt.svg — Diagramm: Klasse vs. Objekt
⬇️ stack-vs-heap.svg — Diagramm: Stack vs. Heap Speichermodell

🔧 Troubleshooting

Problem: „Cannot find symbol“ bei Klassennamen

error: cannot find symbol
    Auto meinAuto = new Auto();
    ^

Lösung:

Ist die Klasse im gleichen Paket?
Fehlt der Import?
Ist der Klassenname richtig geschrieben (Groß-/Kleinschreibung)?

Problem: „class is public, should be declared in a file named…“

error: class Auto is public, should be declared in Auto.java

Lösung: Dateiname muss exakt wie die public Klasse heißen. Auto.java für public class Auto.

Problem: Package-Struktur stimmt nicht

error: package de.javafleet.model does not exist

Lösung: Die Ordnerstruktur muss zum Package-Namen passen:

package de.javafleet.model; → Datei liegt in de/javafleet/model/

🔗 Resources & Links

🟢 Für Einsteiger

Ressource	Beschreibung	Sprache
Oracle Java Tutorials — Classes	Offizielle Doku, sehr gründlich	🇬🇧
W3Schools Java Classes	Einfache Erklärungen, interaktiv	🇬🇧
Codecademy — Learn Java	Interaktiver Kurs (Basics kostenlos)	🇬🇧
Java Tutorial für Anfänger (YouTube)	Video-Tutorials auf Deutsch	🇩🇪
Programmieren Starten — Java OOP	Deutsche Erklärungen	🇩🇪

🟡 Für Fortgeschrittene

Ressource	Beschreibung	Sprache
Baeldung — Java Classes & Objects	Tiefergehend, viele Beispiele	🇬🇧
Java Language Specification (JLS)	Die offizielle Spezifikation	🇬🇧
Effective Java (Buch)	Best Practices von Joshua Bloch	🇬🇧
Java Design Patterns	OOP-Patterns in der Praxis	🇬🇧

🔄 Für Umsteiger

Von	Ressource	Was du lernst
C#	Java for C# Developers	Syntax-Unterschiede
C++	Java for C++ Programmers	Kein Pointer, kein delete
PHP	From PHP to Java	Statische Typisierung
Python	Java for Python Developers	Strenge OOP-Regeln

🛠️ Tools & IDEs

Tool	Beschreibung	Link
IntelliJ IDEA	Beste Java-IDE (Community kostenlos)	jetbrains.com/idea
VS Code + Java Pack	Leichtgewichtig, gut für Anfänger	Extension Pack
Eclipse	Klassiker, viele Plugins	eclipse.org
NetBeans	Offiziell von Apache	netbeans.apache.org
Amazon Corretto JDK 21	Unsere JDK-Empfehlung	aws.amazon.com/corretto

📚 Bücher (wenn du tiefer einsteigen willst)

Buch	Autor	Für wen?
Java ist auch eine Insel	Christian Ullenboom	🟢 Einsteiger (Deutsch, kostenlos online)
Head First Java	Kathy Sierra	🟢 Einsteiger (visuell, unterhaltsam)
Effective Java	Joshua Bloch	🟡 Fortgeschrittene (Best Practices)
Clean Code	Robert C. Martin	🟡 Alle (Code-Qualität)

🎓 Interaktive Lernplattformen

JetBrains Academy — Projekt-basiertes Lernen
Exercism — Java Track — Übungen mit Mentoring
LeetCode — Algorithmen üben
Codewars — Gamified Coding Challenges

💬 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, du hast Tag 1 durchgezogen. Das ist mehr als die meisten schaffen!

Morgen geht’s weiter mit Attributen und Methoden — da wird’s richtig praktisch. Wir bauen Objekte, die tatsächlich was können.

Gönn dir erstmal eine Pause. Lass das Gelernte sacken. Und dann: See you tomorrow! 🚀

Nova Trent
Junior Entwicklerin bei Java Fleet Systems Consulting
„Thread-Flüsterin“ — aber das ist eine andere Geschichte… 😄

Tags: #Java #OOP #Klassen #Objekte #Anfänger #Tutorial

[varwandte_artikel=3]

Autor

Ensign Nova Trent

24 Jahre alt, frisch von der Universität als Junior Entwicklerin bei Java Fleet Systems Consulting. Nova ist brilliant in Algorithmen und Datenstrukturen, aber neu in der praktischen Java-Enterprise-Entwicklung. Sie brennt darauf, ihre ersten echten Projekte zu bauen und entdeckt dabei die Lücke zwischen Uni-Theorie und Entwickler-Realität. Sie liebt Star Treck das ist der Grund warum alle Sie Ensign Nova nennen und arbeitet daraufhin das sie Ihren ersten Knopf am Kragen bekommt.

Tag 1 : Java OOP-Konzepte & Deine erste Klasse

📋 Kursübersicht: Java OOP in 10 Tagen

⚡ Das Wichtigste in 30 Sekunden

👋 Nova: „Endlich macht Code Sinn!“

🟢 GRUNDLAGEN

Was ist Objektorientierte Programmierung?

Warum OOP? Was ist der Vorteil?

Klasse vs. Objekt — Der wichtigste Unterschied

Deine erste Klasse schreiben

Objekte erzeugen mit new

Pakete (Packages) — Ordnung muss sein

🟡 PROFESSIONALS

Für C#-Umsteiger: Fast wie zuhause

Für C++-Umsteiger: Weniger Kontrolle, mehr Sicherheit

Für PHP-Umsteiger: Willkommen in der typisierten Welt

Für alle Umsteiger: Lombok — Dein Getter/Setter-Retter

Für alle Umsteiger: Java’s Eigenheiten

Best Practices für Klassennamen

Packages in der Praxis

🔵 BONUS

Wann ist etwas eine Klasse?

Objekte im Speicher — Was passiert bei new?

Ausblick: Was kommt noch?

💬 Real Talk

✅ Checkpoint: Hast du es verstanden?

Quiz

Mini-Challenge

❓ FAQ — Häufig gestellte Fragen

📚 Quiz-Lösungen

Frage 1: Was ist der Unterschied zwischen einer Klasse und einem Objekt?

Frage 2: Was macht der new-Operator?

Frage 3: Wie viele public Klassen darf eine .java-Datei enthalten?

Frage 4: Was muss die ERSTE Zeile einer Java-Datei sein, wenn du ein Paket verwendest?

Frage 5: Wie erzeugst du ein Hund-Objekt und rufst bellen() auf?

🎉 Tag 1 geschafft!

🔮 Wie geht’s weiter?

📦 Downloads

🔧 Troubleshooting

🔗 Resources & Links

🟢 Für Einsteiger

🟡 Für Fortgeschrittene

🔄 Für Umsteiger

🛠️ Tools & IDEs

📚 Bücher (wenn du tiefer einsteigen willst)

🎓 Interaktive Lernplattformen

💬 Feedback

👋 Bis morgen!

Autor

Ähnliche Artikel

Tag 3 : Datenkapselung & Sichtbarkeit

GraalVM Teil 1: „Der heilige Graal“ – Von einem Wissenschaftler erklärt

Tag 1: Listen – Dein Upgrade von Arrays

Schreibe einen Kommentar Antwort abbrechen

Objekte erzeugen mit `new`

Objekte im Speicher — Was passiert bei `new`?

Frage 2: Was macht der `new`-Operator?

Frage 3: Wie viele `public` Klassen darf eine `.java`-Datei enthalten?

Frage 5: Wie erzeugst du ein Hund-Objekt und rufst `bellen()` auf?