Ce tipuri de clase există în Java?

În Java există următoarele tipuri principale de clase:

Clasa Standard (Standard Class)
- Poate conține câmpuri, metode, constructori.
- Poate fi moștenită de alte clase, dacă nu este declarată ca final.
- Poate implementa interfețe.
- Se declară cu specificatori de acces (public, protected, default, private).

Clasa Abstractă (Abstract Class)

Se declară cu cuvântul cheie abstract.
Nu poate fi instanțiată direct.
Poate conține metode abstracte (fără implementare) și metode obișnuite.
Este destinată pentru moștenire; subclasele trebuie să implementeze metodele abstracte.

// Clasă abstractă pentru o figură
abstract class Shape {
    abstract double area(); // Metodă abstractă pentru calcularea ariei

    void display() { // Metodă obișnuită
        System.out.println("Aceasta este o formă.");
    }
}

Clasa Finală (Final Class)

Se declară cu cuvântul cheie final.
Nu poate fi moștenită de alte clase.
Se folosește pentru a preveni extinderea clasei, pentru siguranță sau pentru a asigura imutabilitatea implementării.

// Clasă finală care nu poate fi moștenită
final class ImmutableString {
    private final String value;

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

    public String getValue() {
        return value;
    }
}

Enum (Enumerări)
- Un tip special de clasă, destinat să reprezinte un set fix de constante.
- Se declară cu cuvântul cheie enum.
- Constantele enum sunt, implicit, public static final.
- Pot avea câmpuri, metode și constructori (cu modificator private ascuns).
```
// Enum pentru zilele săptămânii
enum DayOfWeek {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
```
Clase Anonime (Anonymous Class)
- Clasă fără nume, creată și instantaniată simultan.
- Adesea folosită pentru implementarea interfețelor sau extinderea claselor "la fața locului", când este nevoie de o utilizare unică.
- Nu pot avea constructori expliciți.
```
// Crearea unei clase anonime care implementează interfața Runnable
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Rulează într-o clasă anonimă.");
    }
};
```

Clase Încorporate (Nested Class)

Clase declarate în interiorul altei clase.
Există două tipuri:
- Clase Încorporate Statice (Static Nested Class): declarate cu static. Nu au acces direct la membrii non-statice ai clasei exterioare. Sunt instantiate ca clase obișnuite.
- Clase Interioare (Inner Class): nu sunt declarate cu static. Au acces la toți membrii clasei exterioare, inclusiv private. Necesită o instanță a clasei exterioare pentru a fi create.

// Clasă exterioară
class OuterClass {
    private String outerField = "Outer";

    // Clasă încorporată static
    static class StaticNestedClass {
        void display() {
            System.out.println("În interiorul StaticNestedClass.");
            // Nu are acces direct la outerField
        }
    }

    // Clasă interioară
    class InnerClass {
        void display() {
            System.out.println("În interiorul InnerClass. outerField: " + outerField); // Acces la outerField
        }
    }
}

Clase de Înregistrare (Record - din Java 14)
- Se declară cu cuvântul cheie record.
- Destinate stocării datelor. Compilatorul generează automat constructorul, metodele de acces (accessor methods), equals(), hashCode() și toString().
- Câmpurile record sunt implicit final.
```
// Record pentru reprezentarea unui punct în spațiul 2D
record Point(int x, int y) {
    // Compilatorul va genera constructorul, metodele x(), y(), equals(), hashCode(), toString()
}
```