Zusammenfassung: Objektorientierte Prinzipien in Java

OO-Prinzipien

Die objektorientierte Programmierung (OOP) basiert auf vier grundlegenden Prinzipien:

1. Abstraktion: Verbergen der komplexen Implementierung und Bereitstellung einer einfachen Schnittstelle.
2. Kapselung: Das Verstecken der inneren Zustände eines Objekts und das Bereitstellen von Methoden, um darauf zuzugreifen oder diese zu ändern.
3. Vererbung: Ermöglicht es einer Klasse, Eigenschaften und Methoden einer anderen Klasse zu übernehmen.
4. Polymorphismus: Ermöglicht es, dass Objekte unterschiedliche Formen annehmen können, was zu flexiblerem Code führt.

Vererbung

Vererbung ist ein Mechanismus, bei dem eine Klasse (Unterklasse) die Eigenschaften und Methoden einer anderen Klasse (Oberklasse) erbt. In Java wird die Vererbung mit dem Schlüsselwort extends implementiert.

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

Vorteile:

• Code-Wiederverwendung.
• Hierarchie der Klassen.

Einschränkungen:

• Eine Klasse kann nur von einer anderen Klasse erben (Einzelvererbung).

Polymorphismus

Polymorphismus bedeutet, dass ein Objekt viele Formen annehmen kann. In Java gibt es zwei Hauptarten von Polymorphismus:

1. Methodenüberladung (Compile-Time Polymorphism): Mehrere Methoden mit dem gleichen Namen, aber unterschiedlichen Parametern.
2. Methodenüberschreibung (Run-Time Polymorphism): Eine Methode der Unterklasse überschreibt eine Methode der Oberklasse.

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();  // Ausgabe: Bark
    }
}

Vorteile:

• Erhöhte Flexibilität und Erweiterbarkeit.

Design Patterns

Design Patterns sind wiederverwendbare Lösungen für häufig auftretende Probleme in der Softwareentwicklung. In Java gibt es viele gängige Muster, hier einige Beispiele:

1. Singleton: Stellt sicher, dass eine Klasse nur eine Instanz hat und global darauf zugegriffen werden kann.

    public class Singleton {
        private static Singleton instance;
   
        private Singleton() {}
   
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
   

2. Factory Pattern: Stellt eine Methode zur Verfügung, um Objekte zu erstellen, ohne die genaue Klasse des Objekts zu spezifizieren.

    interface Animal {
        void sound();
    }
   
    class Dog implements Animal {
        public void sound() {
            System.out.println("Bark");
        }
    }
   
    class AnimalFactory {
        public Animal getAnimal(String type) {
            if (type.equals("Dog")) {
                return new Dog();
            }
            return null;
        }
    }
   

3. Observer Pattern: Ermöglicht es, dass ein Objekt (Subject) eine Liste von Beobachtern (Observers) hat, die benachrichtigt werden, wenn sich der Zustand des Objekts ändert.

    interface Observer {
        void update(String message);
    }
   
    class ConcreteObserver implements Observer {
        @Override
        public void update(String message) {
            System.out.println("Received: " + message);
        }
    }
   
    class Subject {
        private List<Observer> observers = new ArrayList<>();
   
        public void addObserver(Observer observer) {
            observers.add(observer);
        }
   
        public void notifyObservers(String message) {
            for (Observer observer : observers) {
                observer.update(message);
            }
        }
    }
   

Fazit: OOP, mit Vererbung und Polymorphismus, und Design Patterns bieten robuste Konzepte, die den Code modular, wartbar und erweiterbar machen.