Welke soorten klassen zijn er in Java?

In Java zijn de volgende hoofdtypen klassen:

1. Standaardklasse (Standard Class)

   • Kan velden, methoden, constructors bevatten.
   • Kan door andere klassen worden overerfd, tenzij ze als final zijn gedeclareerd.
   • Kan interfaces implementeren.
   • Wordt gedeclareerd met toegangsspecificaties (public, protected, default, private).

2. Abstracte klasse (Abstract Class)

   • Wordt gedeclareerd met het sleutelwoord abstract.
   • Kan niet direct worden geïnstantieerd.
   • Kan abstracte methoden (zonder implementatie) en gewone methoden bevatten.
   • Is bedoeld voor overerving; subklassen moeten de abstracte methoden implementeren.

   // Abstracte klasse voor een vorm
   abstract class Shape {
       abstract double area(); // Abstracte methode voor het berekenen van de oppervlakte
   
       void display() { // Gewone methode
           System.out.println("Dit is een vorm.");
       }
   }
   

3. Finale klassen (Final Class)

   • Worden gedeclareerd met het sleutelwoord final.
   • Kan niet door andere klassen worden uitgebreid.
   • Wordt gebruikt om uitbreiding van de klasse te voorkomen, veiligheid te garanderen of ongewijzigde implementatie te verzekeren.

   // Finale klasse die niet kan worden uitgebreid
   final class ImmutableString {
       private final String value;
   
       public ImmutableString(String value) {
           this.value = value;
       }
   
       public String getValue() {
           return value;
       }
   }
   

4. Enumeraties (Enum)

   • Een speciaal type klasse, bedoeld om een vaste set constanten te vertegenwoordigen.
   • Wordt gedeclareerd met het sleutelwoord enum.
   • Enum-constanten zijn standaard public static final.
   • Kan velden, methoden en constructors hebben (met een verborgen private modifier).

   // Enum voor de dagen van de week
   enum DayOfWeek {
       MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
   }
   

5. Anonieme klassen (Anonymous Class)

   • Klassen zonder naam, die gelijktijdig worden gemaakt en geïnstantieerd.
   • Vaak gebruikt voor het implementeren van interfaces of het uitbreiden van klassen "on the fly" wanneer een eenmalig gebruik vereist is.
   • Kan geen expliciete constructors hebben.

   // Aanmaken van een anonieme klasse die de interface Runnable implementeert
   Runnable r = new Runnable() {
       @Override
       public void run() {
           System.out.println("Uitvoeren in een anonieme klasse.");
       }
   };
   

6. Geneste klassen (Nested Class)

   • Klassen die binnen een andere klasse worden gedeclareerd.
   • Er zijn twee types:
     • Statische geneste klassen (Static Nested Class): gedeclareerd met static. Hebben geen directe toegang tot niet-statische leden van de buitenklasse. Worden als gewone klassen geïnstantieerd.
     • Binnenklassen (Inner Class): niet gedeclareerd met static. Hebben toegang tot alle leden van de buitenklasse, inclusief private. Vereisen een instantie van de buitenklasse om te worden gemaakt.

   // Buitenklasse
   class OuterClass {
       private String outerField = "Outer";
   
       // Statische geneste klasse
       static class StaticNestedClass {
           void display() {
               System.out.println("Binnen StaticNestedClass.");
               // Geen directe toegang tot outerField
           }
       }
   
       // Binnenklasse
       class InnerClass {
           void display() {
               System.out.println("Binnen InnerClass. outerField: " + outerField); // Toegang tot outerField
           }
       }
   }
   

7. Record-klassen (Record - vanaf Java 14)

   • Gedeclareerd met het sleutelwoord record.
   • Gericht op het opslaan van gegevens. De compiler genereert automatisch de constructor, toegangsmethoden (accessor methods), equals(), hashCode() en toString().
   • Velden van records zijn impliciet final.

   // Record voor het voorstellen van een punt in 2D-ruimte
   record Point(int x, int y) {
       // De compiler genereert de constructor, methods x(), y(), equals(), hashCode(), toString()
   }