Fortgeschrittene Programmierkonzepte

In diesem Abschnitt behandeln wir fortgeschrittene Konzepte der objektorientierten Programmierung (OOP), die auf den in Teil 5 behandelten Grundlagen aufbauen. Diese Konzepte richten sich an Studierende, die bereits ein fundiertes Verständnis der Grundlagen haben und weiter in die Tiefe gehen möchten.

1. Polymorphismus vertiefen

Polymorphismus ist ein zentrales Konzept in der OOP, das es ermöglicht, dass Objekte verschiedener Klassen durch die gleiche Schnittstelle angesprochen werden können. In diesem Abschnitt untersuchen wir fortgeschrittene Aspekte des Polymorphismus.

1.1 Dynamische Bindung

Die dynamische Bindung ermöglicht es, dass der zur Laufzeit tatsächlich ausgeführte Methodenaufruf von der tatsächlichen Objekttyp zur Laufzeit bestimmt wird.

Beispiel:

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

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

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound();  // Output: Dog barks
    }
}

1.2 Überladen vs. Überschreiben

Es ist wichtig, den Unterschied zwischen dem Überladen von Methoden (compile-time polymorphism) und dem Überschreiben von Methoden (runtime polymorphism) zu verstehen.

Überladen:

class MathOperations {
    int add(int a, int b) {
        return a + b;
    }

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

Überschreiben:

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

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

2. Abstrakte Klassen und Schnittstellen

Abstrakte Klassen und Schnittstellen sind Werkzeuge, um gemeinsame Schnittstellen für verschiedene Klassen zu definieren, ohne die Implementierung vorzuschreiben.

2.1 Abstrakte Klassen

Abstrakte Klassen können nicht instanziiert werden und dienen dazu, andere Klassen zu erweitern.

Beispiel:

abstract class Animal {
    abstract void sound();

    void sleep() {
        System.out.println("Animal is sleeping");
    }
}

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

2.2 Schnittstellen (Interfaces)

Schnittstellen definieren Methoden, die von jeder implementierenden Klasse bereitgestellt werden müssen.

Beispiel:

interface Animal {
    void sound();
}

class Dog implements Animal {
    public void sound() {
        System.out.println("Dog barks");
    }
}

3. Generics und Typinferenz

Generics ermöglichen es, Klassen und Methoden zu erstellen, die mit verschiedenen Datentypen arbeiten können, ohne auf Typprüfungen oder Typumwandlungen angewiesen zu sein.

3.1 Generics in Klassen und Methoden

Beispiel:

class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

3.2 Begrenzte Typ-Parameter

Sie können generische Typen so einschränken, dass sie nur einen bestimmten Typ oder seine Unterklassen akzeptieren.

Beispiel:

public <T extends Number> void inspect(T t) {
    System.out.println("T: " + t.getClass().getName());
}

4. Reflexion in Java

Reflexion ist ein leistungsstarkes Feature in Java, das es ermöglicht, zur Laufzeit Informationen über Klassen, Methoden und Felder zu erhalten und zu manipulieren.

4.1 Verwendung von Reflexion

Reflexion kann verwendet werden, um Klassen dynamisch zu laden, Methoden aufzurufen und auf private Felder zuzugreifen.

Beispiel:

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.util.ArrayList");
            Method[] methods = clazz.getDeclaredMethods();

            for (Method method : methods) {
                System.out.println(method.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Fazit

Die in diesem Abschnitt behandelten fortgeschrittenen Konzepte erweitern Ihre Fähigkeiten in der objektorientierten Programmierung und machen es möglich, flexibleren, leistungsfähigeren und wartbaren Code zu schreiben. Es ist entscheidend, diese Konzepte zu verstehen und zu üben, um Ihre Programmierkenntnisse weiter zu vertiefen.