¿Qué tipos de clases existen en Java?

En Java, existen los siguientes tipos principales de clases:

Clase estándar (Standard Class)
- Puede contener campos, métodos, constructores.
- Puede ser heredada por otras clases, si no se declara como final.
- Puede implementar interfaces.
- Se declara con modificadores de acceso (public, protected, default, private).
Clase abstracta (Abstract Class)
- Se declara con la palabra clave abstract.
- No se pueden instanciar directamente.
- Puede contener métodos abstractos (sin implementación) y métodos normales.
- Está destinada a ser heredada; las subclases deben proporcionar la implementación de los métodos abstractos.
```
// Clase abstracta para una figura
abstract class Shape {
    abstract double area(); // Método abstracto para calcular el área

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

Clase final (Final Class)

Se declara con la palabra clave final.
No puede ser heredada por otras clases.
Se usa para prevenir la extensión de la clase, garantizar la seguridad o la inmutabilidad de la implementación.

// Clase final que no puede ser heredada
final class ImmutableString {
    private final String value;

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

    public String getValue() {
        return value;
    }
}

Enumeraciones (Enum)
- Un tipo especial de clase, destinado a representar un conjunto fijo de constantes.
- Se declaran con la palabra clave enum.
- Las constantes de la enumeración son public static final por defecto.
- Pueden tener campos, métodos y constructores (con modificador private oculto).
```
// Enumeración de días de la semana
enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
```
Clases anónimas (Anonymous Class)
- Clase sin nombre, creada e instanciada al mismo tiempo.
- Se usan comúnmente para implementar interfaces o extender clases "en línea" cuando se requiere un uso único.
- No pueden tener constructores explícitos.
```
// Creando una clase anónima que implementa Runnable
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in an anonymous class.");
    }
};
```

Clases internas (Nested Class)

Clases declaradas dentro de otra clase.
Hay dos tipos:
- Clases internas estáticas (Static Nested Class): se declaran con static. No tienen acceso directo a los miembros no estáticos de la clase exterior. Se instancian como clases normales.
- Clases internas (Inner Class): no se declaran como static. Tienen acceso a todos los miembros de la clase exterior, incluyendo private. Requieren una instancia de la clase exterior para crear una instancia.

// Clase exterior
class OuterClass {
    private String outerField = "Outer";

    // Clase interna estática
    static class StaticNestedClass {
        void display() {
            System.out.println("Inside StaticNestedClass.");
            // No tiene acceso directo a outerField
        }
    }

    // Clase interna
    class InnerClass {
        void display() {
            System.out.println("Inside InnerClass. outerField: " + outerField); // Acceso a outerField
        }
    }
}

Clases record (Record - desde Java 14)
- Se declaran con la palabra clave record.
- Destinadas a almacenar datos. El compilador genera automáticamente el constructor, métodos de acceso a los campos (accessor methods), equals(), hashCode() y toString().
- Los campos del record son implícitamente final.
```
// Record para representar un punto en un espacio 2D
record Point(int x, int y) {
    // El compilador generará el constructor, métodos x(), y(), equals(), hashCode(), toString()
}
```