Fortgeschrittene Programmierkonzepte

Dieser Abschnitt ist für Studierende gedacht, die bereits ein solides Verständnis der objektorientierten Programmierung (OOP) haben und sich tiefer in fortgeschrittene Konzepte vertiefen möchten. Die folgenden Themen erweitern die Grundlagen, die im vorangegangenen Material behandelt wurden.

1. Entwurfsmuster (Design Patterns)

Entwurfsmuster sind wiederverwendbare Lösungen für häufig auftretende Probleme in der Softwareentwicklung. Hier sind einige der bekanntesten Entwurfsmuster:

1.1 Singleton Pattern

Das Singleton-Muster stellt sicher, dass eine Klasse nur eine Instanz hat und bietet einen globalen Zugriffspunkt auf diese Instanz.

Beispiel:

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

1.2 Factory Pattern

Das Factory-Muster bietet eine Schnittstelle zur Erstellung von Objekten, ohne dass die exakte Klasse des zu erstellenden Objekts bekannt sein muss.

Beispiel:

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

public class Square implements Shape {
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

2. Solid Principles

Die SOLID-Prinzipien sind Richtlinien für gutes Softwaredesign und helfen dabei, Code verständlicher, flexibler und wartbarer zu machen.

2.1 Single Responsibility Principle (SRP)

Eine Klasse sollte nur eine einzige Verantwortlichkeit haben, d.h., sie sollte nur einen Grund zur Änderung haben.

2.2 Open/Closed Principle (OCP)

Software-Entitäten (Klassen, Module, Funktionen, etc.) sollten offen für Erweiterung, aber geschlossen für Veränderungen sein.

3. Rekursion

Rekursion ist eine Methode, bei der eine Funktion sich selbst aufruft, um ein Problem zu lösen. Rekursion wird häufig zur Lösung von Problemen verwendet, die auf kleinere Teilprobleme reduziert werden können.

Beispiel:

public int factorial(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

4. Generische Programmierung

Generics ermöglichen es Ihnen, Klassen, Schnittstellen und Methoden zu definieren, die Parameter vom Typ akzeptieren. Dies macht Ihren Code flexibler und wiederverwendbarer.

Beispiel:

public class Box<T> {
    private T t;

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

    public T get() {
        return t;
    }
}

5. Lambda-Ausdrücke und Streams

Java 8 führte Lambda-Ausdrücke und Streams ein, die das Schreiben von kompaktem und ausdrucksstarkem Code ermöglichen.

5.1 Lambda-Ausdrücke

Lambda-Ausdrücke sind eine kürzere Form, um anonyme Klassen mit einer Methode zu schreiben.

Beispiel:

List<String> names = Arrays.asList("Anna", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

5.2 Streams

Streams ermöglichen es, große Datenmengen in einer funktionalen Art und Weise zu verarbeiten.

Beispiel:

List<String> names = Arrays.asList("Anna", "Bob", "Charlie");
names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

Fazit

Diese fortgeschrittenen Konzepte bieten Ihnen Werkzeuge und Techniken, um robustere und flexiblere Software zu entwickeln. Es ist wichtig, diese Konzepte zu verstehen und zu üben, um ein besserer Programmierer zu werden.