Welche Klassentypen gibt es in Java?

In Java gibt es die folgenden Haupttypen von Klassen:

Standardklasse (Standard Class)
- Kann Felder, Methoden, Konstruktoren enthalten.
- Kann von anderen Klassen erben, wenn sie nicht als final deklariert ist.
- Kann Schnittstellen implementieren.
- Wird mit Zugriffsmodifikatoren (public, protected, default, private) deklariert.
Abstrakte Klasse (Abstract Class)
- Wird mit dem Schlüsselwort abstract deklariert.
- Kann nicht direkt instanziiert werden.
- Kann abstrakte Methoden (ohne Implementierung) und normale Methoden enthalten.
- Ist zur Vererbung gedacht; Unterklassen müssen die abstrakten Methoden implementieren.
```
// Abstrakte Klasse für eine Form
abstract class Shape {
    abstract double area(); // Abstrakte Methode zur Flächenberechnung

    void display() { // Normale Methode
        System.out.println("This is a shape.");
    }
}
```

Endgültige Klasse (Final Class)

Wird mit dem Schlüsselwort final deklariert.
Kann nicht von anderen Klassen erben.
Wird verwendet, um die Erweiterung der Klasse zu verhindern, Sicherheit zu gewährleisten oder Unveränderlichkeit der Implementierung zu sichern.

// Endgültige Klasse, die nicht vererbt werden kann
final class ImmutableString {
    private final String value;

    public ImmutableString(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

Enums (Aufzählungstypen)
- Ein spezieller Klassentyp, der für die Darstellung eines festen Satzes von Konstanten vorgesehen ist.
- Wird mit dem Schlüsselwort enum deklariert.
- Die Konstanten der Aufzählung sind standardmäßig public static final.
- Können Felder, Methoden und Konstruktoren (mit private Modifier) haben.
```
// Aufzählung der Wochentage
enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
```
Anonyme Klassen (Anonymous Class)
- Klassen ohne Namen, die gleichzeitig erstellt und instanziiert werden.
- Werden häufig zur Implementierung von Schnittstellen oder zur Erweiterung von Klassen "on the fly" verwendet, wenn nur einmalige Nutzung erforderlich ist.
- Können keine expliziten Konstruktoren haben.
```
// Erstellen einer anonymen Klasse, die Runnable implementiert
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in an anonymous class.");
    }
};
```

Verschachtelte Klassen (Nested Class)

Klassen, die innerhalb einer anderen Klasse deklariert sind.
Es gibt zwei Typen:
- Statische verschachtelte Klassen (Static Nested Class): werden mit static deklariert. Haben keinen direkten Zugriff auf nicht-statische Mitglieder der äußeren Klasse. Werden wie normale Klassen instanziiert.
- Innere Klassen (Inner Class): werden nicht als static deklariert. Haben Zugriff auf alle Mitglieder der äußeren Klasse, inklusive private. Benötigen eine Instanz der äußeren Klasse, um ihre Instanz zu erstellen.

// Äußere Klasse
class OuterClass {
    private String outerField = "Outer";

    // Statische verschachtelte Klasse
    static class StaticNestedClass {
        void display() {
            System.out.println("Inside StaticNestedClass.");
            // Kein direkter Zugriff auf outerField
        }
    }

    // Innere Klasse
    class InnerClass {
        void display() {
            System.out.println("Inside InnerClass. outerField: " + outerField); // Zugriff auf outerField
        }
    }
}

Aufzählungsklassen (Record - seit Java 14)
- Werden mit dem Schlüsselwort record deklariert.
- Dienen zur Speicherung von Daten. Der Compiler generiert automatisch den Konstruktor, Zugriffsmethoden (accessor methods), equals(), hashCode() und toString().
- Die Felder des Records sind implizit final.
```
// Record zur Darstellung eines Punktes im 2D-Raum
record Point(int x, int y) {
    // Der Compiler generiert den Konstruktor, Methoden x(), y(), equals(), hashCode(), toString()
}
```