Von OOA über OOD zu OOP

6. März 2025 - Lesezeit: 4 Minuten

In meinem Blog geht es ja hauptsächlich um Java-Themen sowie begleitendes Material. Hier möchte ich einmal über eine häufig auftretende Frage sprechen: Wie kommt man von der objektorientierten Analyse zur objektorientierten Programmierung.

Lass uns zunächst einmal die ganzen Abkürzungen auflösen um das Verständnis zu verschärfen:

• OOA - Objektorientierte Analyse
• OOD - Objektorientierter Entwurf
• OOP - Objektorientierte Programmierung

Wie du vielleicht merkst, sprechen wir immer von Objekten. Objekte sind immer Dinge aus der realen Welt, in der (Java)-Programmierung sind das im Grunde immer Klassen.

Objektorientierte Analyse und objektorientierte Programmierung sind zwei aufeinanderfolgende Schritte bei der Softwareentwicklung und ich möchte das in diesem Beitrag anhand eines einfachen Beispiels zeigen.

Objektorientierte Analyse

Die objektorientierte Analyse dient dazu, die Problemstellung zu analysieren und ein Modell zu erstellen, das die realen Gegebenheiten widerspiegelt. Dabei betrachten wir die relevanten Objekte, ihre Eigenschaften (die Attribute) und ihr Verhalten (die Methoden).

Verwaltung eines kleinen Tierheims (vereinfacht)

Bei der Verwaltung eines kleinen Tierheims, ergeben sich folgende Anforderungen:

• Ein Tierheim verwaltet verschiedene Tiere
• Jedes Tier hat einen Namen, eine Art und ein Alter
• Tiere können gefüttert werden und geben dabei eine spezifische Reaktion aus

Identifikation der Objekte:

• Die zentrale Entität (hier die Klasse/das Objekt) ist Tier
• Tier hat die Attribute name, art und alter
• Tier hat die Methode fuettern(), welche eine Nachricht ausgibt

Damit haben wir die objektorientierte Analyse abgeschlossen denn wir wissen nun, welche relevanten Objekte wir zur Lösung der Problemstellung benötigen.

Objektorientierter Entwurf

Nun geht es darum, eine Klassendefinition zu erstellen, die wir aus der Analyse ermittelt haben.

Klassendiagramm (vereinfacht)

Hier definieren wir somit eine Klasse Tier, die die identifizierten Attribute und Methoden enthält.

Objektorientierte Programmierung

Basierend auf dem Entwurf können wir nun die Klassen in Java implementieren:

public class Tier {
    private String name;
    private String art;
    private int alter;

    public Tier(String name, String art, int alter) {
        this.name = name;
        this.art = art;
        this.alter = alter;
    }

    public void fuettern() {
        System.out.println(name + " das " + art + " freut sich über das Futter!");
    }

    public String getName() {
        return name;
    }

    public String getArt() {
        return art;
    }

    public int getAlter() {
        return alter;
    }
}

Nutzung der Klasse

Nachdem wir die Klasse erstellt haben, sind wir in der Lage Objekte vom Typ Tier zu erstellen und mit ihnen zu interagieren:

public class Tierheim {
    public static void main(String[] args) {
        Tier hund = new Tier("Bello", "Hund", 3);
        Tier katze = new Tier("Minka", "Katze", 2);

        hund.fuettern();
        katze.fuettern();
    }
}

Auf der Konsole erhalten wir die folgende Ausgabe:

Bello das Hund freut sich über das Futter!
Minka das Katze freut sich über das Futter!

Anm.: Ja, "das" Hund oder "das Katze" ist hier unglücklich im Beispiel. Ich habe es dennoch so gelassen um hier die Komplexität des Beispiel nicht weiter zu erhöhen.

Damit haben wir an dieser Stelle mit diesem vereinfachten Beispiel das Thema eigentlich schon durch. Wir haben die objektorientierte Analyse durchgeführt, einen objektorientierten Entwurf erstellt und danach unter Verwendung der objektorientierten Programmierung unsere benötige Klasse implementiert.

Anhand dieses einfachen Beispiels sollten dir die unterschiedlichen Konzepte auf simple Art und Weise verständlich erscheinen.

Erweiterung durch Vererbung

Um das Konzept der objektorientierten Programmierung anhand unseres Tierheims ein wenig zu vertiefen, können wir spezifische Tierarten als eigene Klassen anlegen und die Basisklasse Tier erweitern:

class Hund extends Tier {
    public Hund(String name, int alter) {
        super(name, "Hund", alter);
    }

    @Override
    public void fuettern() {
        System.out.println(getName() + " wedelt mit dem Schwanz vor Freude!");
    }
}

class Katze extends Tier {
    public Katze(String name, int alter) {
        super(name, "Katze", alter);
    }

    @Override
    public void fuettern() {
        System.out.println(getName() + " schnurrt zufrieden.");
    }
}

Damit sind wir nun in der Lage, spezialisierte Tiere mit angepasstem Verhalten zu erzeugen:

public class TierheimErweitert {
    public static void main(String[] args) {
        Hund hund = new Hund("Bello", 3);
        Katze katze = new Katze("Minka", 2);

        hund.fuettern();
        katze.fuettern();
    }
}

Auf der Konsole erhalten wir folgende Ausgabe:

Bello wedelt mit dem Schwanz vor Freude!
Minka schnurrt zufrieden.

Ich hoffe, ich konnte dir hiermit nun auch einen erweiterten Überblick über die verwendeten Konzepte liefern und deutlich machen, was das alles genau bedeutet und wie man diese Konzepte anwendet.

Solltest du noch Fragen dazu haben, freue ich mich über deinen Kommentar unter diesem Beitrag.