Quali sono i tipi di classi in Java?

In Java, esistono i seguenti principali tipi di classi:

Classe Standard (Standard Class)
- Può contenere campi, metodi, costruttori.
- Può essere ereditata da altre classi, se non dichiarata come final.
- Può implementare interfacce.
- Viene dichiarata con modificatori di accesso (public, protected, default, private).
Classe Astratta (Abstract Class)
- Viene dichiarata con la parola chiave abstract.
- Non può essere istanziata direttamente.
- Può contenere metodi astratti (senza implementazione) e metodi normali.
- È destinata all'ereditarietà; le sottoclassi devono fornire l'implementazione dei metodi astratti.
```
// Classe astratta per una figura
abstract class Shape {
    abstract double area(); // Metodo astratto per il calcolo dell'area

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

Classe Finale (Final Class)

Viene dichiarata con la parola chiave final.
Non può essere ereditata da altre classi.
Viene usata per prevenire l'estensione della classe, garantire la sicurezza o l'immutabilità dell'implementazione.

// Classe finale che non può essere ereditata
final class ImmutableString {
    private final String value;

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

    public String getValue() {
        return value;
    }
}

Enumerazioni (Enum)
- Un tipo speciale di classe, destinato a rappresentare un insieme fisso di costanti.
- Viene dichiarata con la parola chiave enum.
- Le costanti dell'enumerazione sono public static final per impostazione predefinita.
- Possono avere campi, metodi e costruttori (con modificatore private).
```
// Enumerazione dei giorni della settimana
enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
```
Classi Anonime (Anonymous Class)
- Classe senza nome, creata e istanziata contemporaneamente.
- Spesso usata per implementare interfacce o estendere classi "al volo", quando è richiesta un'uso singolo.
- Non possono avere costruttori espliciti.
```
// Creazione di una classe anonima che implementa Runnable
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in an anonymous class.");
    }
};
```

Classi Annidate (Nested Class)

Classi dichiarate all'interno di un'altra classe.
Ce ne sono due tipi:
- Classi Annidate Statiche (Static Nested Class): dichiarate con static. Non hanno accesso diretto ai membri non statici della classe esterna. Vengono istanziate come classi normali.
- Classi Interne (Inner Class): non sono dichiarate come static. Hanno accesso a tutti i membri della classe esterna, inclusi private. Richiedono un'istanza della classe esterna per creare la loro istanza.

// Classe esterna
class OuterClass {
    private String outerField = "Outer";

    // Classe Annidata Statica
    static class StaticNestedClass {
        void display() {
            System.out.println("Inside StaticNestedClass.");
            // Nessun accesso diretto a outerField
        }
    }

    // Classe Interna
    class InnerClass {
        void display() {
            System.out.println("Inside InnerClass. outerField: " + outerField); // Accesso a outerField
        }
    }
}

Classi Record (Record - da Java 14)
- Vengono dichiarate con la parola chiave record.
- Sono destinate a contenere dati. Il compilatore genera automaticamente il costruttore, i metodi di accesso ai campi (accessor methods), equals(), hashCode() e toString().
- I campi del record sono implicitamente final.
```
// Record per rappresentare un punto nello spazio 2D
record Point(int x, int y) {
    // Il compilatore genererà il costruttore, i metodi x(), y(), equals(), hashCode(), toString()
}
```