Quels sont les types de classes en Java?

En Java, il existe les principaux types de classes suivants :

Classe standard (Standard Class)
- Peut contenir des champs, méthodes, constructeurs.
- Peut être héritée par d'autres classes, si elle n'est pas déclarée comme final.
- Peut implémenter des interfaces.
- Déclarée avec des modificateurs d'accès (public, protected, default, private).
Classe abstraite (Abstract Class)
- Déclarée avec le mot-clé abstract.
- Ne peut pas être instanciée directement.
- Peut contenir des méthodes abstraites (sans implémentation) et des méthodes normales.
- Destinée à être héritée ; les sous-classes doivent fournir l'implémentation des méthodes abstraites.
```
// Classe abstraite pour une figure
abstract class Shape {
    abstract double area(); // Méthode abstraite pour calculer la surface

    void display() { // Méthode normale
        System.out.println("This is a shape.");
    }
}
```

Classe finale (Final Class)

Déclarée avec le mot-clé final.
Ne peut pas être héritée par d'autres classes.
Utilisée pour empêcher l'extension de la classe, assurer la sécurité ou l'immutabilité de l'implémentation.

// Classe finale qui ne peut pas être héritée
final class ImmutableString {
    private final String value;

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

    public String getValue() {
        return value;
    }
}

Enumérations (Enum)
- Un type spécial de classe, destiné à représenter un ensemble fixe de constantes.
- Déclaré avec le mot-clé enum.
- Les constantes de l'énumération sont public static final par défaut.
- Peut avoir des champs, méthodes et constructeurs (avec modificateur private).
```
// Enum pour les jours de la semaine
enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
```
Classes anonymes (Anonymous Class)
- Classe sans nom, créée et instanciée en même temps.
- Souvent utilisées pour implémenter des interfaces ou étendre des classes "sur le vif", lorsque l'on a besoin d'une utilisation unique.
- Ne peuvent pas avoir de constructeurs explicites.
```
// Création d'une classe anonyme implémentant Runnable
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in an anonymous class.");
    }
};
```

Classes imbriquées (Nested Class)

Classes déclarées à l'intérieur d'une autre classe.
Il en existe deux types :
- Classes imbriquées statiques (Static Nested Class) : déclarées avec static. N'ont pas accès directement aux membres non statiques de la classe extérieure. S'instancient comme des classes normales.
- Classes internes (Inner Class) : ne sont pas déclarées comme static. Ont accès à tous les membres de la classe extérieure, y compris private. Nécessitent une instance de la classe extérieure pour créer leur instance.

// Classe extérieure
class OuterClass {
    private String outerField = "Outer";

    // Classe imbriquée statique
    static class StaticNestedClass {
        void display() {
            System.out.println("Inside StaticNestedClass.");
            // Pas d'accès direct à outerField
        }
    }

    // Classe interne
    class InnerClass {
        void display() {
            System.out.println("Inside InnerClass. outerField: " + outerField); // Accès à outerField
        }
    }
}

Classes record (Record - depuis Java 14)
- Déclarées avec le mot-clé record.
- Destinées à stocker des données. Le compilateur génère automatiquement le constructeur, les méthodes d'accès aux champs (accessor methods), equals(), hashCode() et toString().
- Les champs du record sont implicitement final.
```
// Record pour représenter un point dans un espace 2D
record Point(int x, int y) {
    // Le compilateur générera le constructeur, méthodes x(), y(), equals(), hashCode(), toString()
}
```