Java OOP Cheatsheet

6 Kernkonzepte

Die wichtigsten OOP-Konzepte in Java: Klassen & Objekte · Kapselung · Vererbung · Polymorphie · Abstrakte Klassen · Interfaces Die objektorientierte Programmierung (OOP) ist das Herzstück von Java. Diese Konzepte sind essenziell für die Erstellung modularer, wiederverwendbarer und wartbarer Software.

Klassen & Objekte – Blaupause & Instanz

class · new · Konstruktor · this

public class Person { private String name; private int alter; public Person(String name, int alter) { this.name = name; this.alter = alter; } }

Klassen sind Blaupausen für Objekte. Sie definieren Attribute (Felder) und Verhalten (Methoden). Ein Objekt ist eine konkrete Instanz einer Klasse, erstellt mit new.

Wichtige Konzepte

Konzept	Beschreibung
class	Definiert einen neuen Datentyp (Blaupause)
new	Erstellt eine neue Instanz (Objekt)
Konstruktor	Methode mit gleichem Namen wie Klasse – initialisiert Objekt
this	Verweist auf das aktuelle Objekt
Felder (Attribute)	Zustand eines Objekts (Variablen)
Methoden	Verhalten eines Objekts (Funktionen)
Getter/Setter	Methoden zum Zugriff auf private Felder

Beispiele

public class Person {

private String name;

private int alter;

public Person(String name, int alter) {

this.name = name;

this.alter = alter;

}

public void vorstellen() {

System.out.println("Ich bin " + name + " und " + alter + " Jahre alt.");

}

// Verwendung:

Person p = new Person("Anna", 25);

p.vorstellen(); // Ausgabe: Ich bin Anna und 25 Jahre alt.

Tipp: Ein Konstruktor hat keinen Rückgabetyp (nicht einmal void) und heißt exakt wie die Klasse. Wenn Sie keinen Konstruktor definieren, erzeugt Java einen Standard-Konstruktor ohne Parameter.

Kapselung – Daten verstecken

private · public · protected · Getter/Setter

private String name; // nur innerhalb der Klasse sichtbar public String getName() { return name; } public void setName(String name) { this.name = name; }

Kapselung (Encapsulation) verbirgt interne Daten und stellt kontrollierten Zugriff über öffentliche Methoden (Getter/Setter) bereit. Dies schützt die Datenintegrität und ermöglicht spätere Änderungen.

Sichtbarkeitsmodifikatoren

Modifikator	Sichtbarkeit
private	Nur innerhalb der eigenen Klasse
default (kein Modifikator)	Innerhalb des Pakets (package-private)
protected	Innerhalb des Pakets + in Unterklassen
public	Überall sichtbar

Beispiele

public class Bankkonto {

private double kontostand;

public double getKontostand() {

return kontostand;

}

public void einzahlen(double betrag) {

if (betrag > 0) {

this.kontostand += betrag;

}

// Kein direkter Zugriff auf kontostand von außen!

// konto.kontostand = 100; // Fehler!

Tipp: Machen Sie Felder private und bieten Sie public Getter/Setter an. Das erlaubt später, Validierungen oder Logik hinzuzufügen, ohne die Schnittstelle zu ändern.

Vererbung – extends

extends · super · @Override

public class Tier { ... } public class Hund extends Tier { ... } super.methodenName();

Vererbung (Inheritance) ermöglicht es, eine neue Klasse (Hund) von einer bestehenden Klasse (Tier) abzuleiten. Die Unterklasse erbt alle nicht-privaten Felder und Methoden der Oberklasse.

Wichtige Konzepte

Konzept	Beschreibung
extends	Definiert die Vererbungsbeziehung
super	Verweist auf die Oberklasse (Konstruktor/Methode)
@Override	Annotation – Methode überschreibt Oberklassen-Methode
final (Klasse)	Klasse kann nicht vererbt werden
final (Methode)	Methode kann nicht überschrieben werden

Beispiele

public class Tier {

private String name;

public Tier(String name) { this.name = name; }

public void lautGeben() { System.out.println("..."); }

}

public class Hund extends Tier {

public Hund(String name) {

super(name); // Oberklassen-Konstruktor aufrufen

}

@Override

public void lautGeben() {

System.out.println("Wau Wau!");

}

Tipp: Verwenden Sie super() im Konstruktor, um den Konstruktor der Oberklasse aufzurufen – das muss die erste Anweisung im Konstruktor sein.

Polymorphie – Viele Formen

Überschreiben · Überladen · instanceof

Tier t = new Hund("Bello"); t.lautGeben(); // "Wau Wau!" (obwohl Typ Tier) if (t instanceof Hund) { ... }

Polymorphie bedeutet, dass ein Objekt in verschiedenen Formen (Typen) auftreten kann. Überschreiben (Override) ermöglicht unterschiedliche Implementierungen in Unterklassen. Überladen (Overload) erlaubt mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern.

Arten der Polymorphie

Art	Beschreibung	Beispiel
Überschreiben (Override)	Unterklasse überschreibt Methode der Oberklasse	@Override void lautGeben()
Überladen (Overload)	Mehrere Methoden gleicher Name, unterschiedliche Parameter	void lautGeben() vs. void lautGeben(int anzahl)
Subtyp-Polymorphie	Objekt einer Unterklasse wird als Oberklasse behandelt	Tier t = new Hund()

Beispiele

// Überschreiben (Override) – siehe Vererbungs-Beispiel

// Überladen (Overload)

public class Mathe {

public int addiere(int a, int b) { return a + b; }

public double addiere(double a, double b) { return a + b; }

public int addiere(int a, int b, int c) { return a + b + c; }

}

// Subtyp-Polymorphie

Tier meinTier = new Hund("Bello");

meinTier.lautGeben(); // Aufruf der Hund-Methode (Wau Wau!)

Tipp: Verwenden Sie @Override als Annotation vor überschriebenen Methoden. Es hilft dem Compiler, Fehler zu erkennen (z.B. Tippfehler im Methodennamen).

Abstrakte Klassen – abstract

abstract class · abstract method

public abstract class Fahrzeug { private String marke; public abstract void fahren(); }

Abstrakte Klassen können nicht instanziiert werden. Sie dienen als Vorlage für Unterklassen und können sowohl abstrakte als auch konkrete Methoden enthalten. Abstrakte Methoden müssen in konkreten Unterklassen implementiert werden.

Eigenschaften

Eigenschaft	Beschreibung
abstract class	Kann nicht instanziiert werden (kein new)
abstract method	Nur Deklaration, keine Implementierung
konkrete Methoden	Können in abstrakter Klasse implementiert werden
Felder/Konstruktoren	Wie bei normalen Klassen möglich

Beispiele

public abstract class Fahrzeug {

private String marke;

public Fahrzeug(String marke) { this.marke = marke; }

public String getMarke() { return marke; }

public abstract void fahren();

}

public class Auto extends Fahrzeug {

public Auto(String marke) { super(marke); }

@Override

public void fahren() {

System.out.println("Das Auto fährt auf der Straße.");

}

Tipp: Verwenden Sie abstrakte Klassen, wenn Sie gemeinsame Funktionalität für verwandte Klassen bereitstellen möchten, aber eine vollständige Implementierung nicht sinnvoll ist.

Interfaces – implement

interface · implements · default method

public interface Fahrbar { void fahren(); } public class Auto implements Fahrbar { ... }

Interfaces definieren einen Vertrag (Kontrakt) für Klassen. Sie enthalten abstrakte Methoden (Standard) und seit Java 8 auch default- und static-Methoden. Eine Klasse kann mehrere Interfaces implementieren.

Wichtige Konzepte

Konzept	Beschreibung
interface	Definiert abstrakte Methoden (alle sind public abstract)
implements	Klasse implementiert ein Interface
default method	Methode mit Standard-Implementierung (seit Java 8)
static method	Statische Methode im Interface (seit Java 8)
Mehrfachvererbung	Eine Klasse kann mehrere Interfaces implementieren

Beispiele

public interface Fahrbar {

void fahren(); // automatisch public abstract

default void hupe() { // Standard-Implementierung

System.out.println("Hup!");

}

public interface Fliegbar {

void fliegen();

}

public class Flugauto implements Fahrbar, Fliegbar {

@Override public void fahren() { ... }

@Override public void fliegen() { ... }

}

Tipp: Interfaces sind der Schlüssel zur lossenschaftlichen Kopplung (Loose Coupling) in Java. Sie ermöglichen es, den Code gegen Interfaces statt gegen konkrete Implementierungen zu programmieren.

Java OOP im Überblick

class Blaupause für Objekte
Attribute + Methoden

private Kapselung
Daten verstecken

extends Vererbung
Oberklasse erweitern

@Override Polymorphie
Methode überschreiben

abstract Abstrakte Klasse/Methode
Keine Instanziierung

implements Interface
Mehrfachvererbung

Quick Summary

class

Klasse

private

Kapselung

extends

Vererbung

@Override

Polymorphie

abstract

Abstrakte Klasse

implements

Interface

class Auto extends Fahrzeug implements Fahrbar · @Override void fahren() · private String name; public String getName()