Java abstracte klassen en methoden

Deze tutorial biedt een duidelijke, voorbeeld-gedreven verkenning van Java abstracte klassen en methoden, en legt uit hoe abstractie in Java geïmplementeerd wordt.

Java abstracte klasse

In Java kan een abstracte klasse niet geïnstantieerd worden. Het abstract sleutelwoord markeert de klasse als abstract. Bijvoorbeeld,

// creeer een abstracte klasse abstract class Taal { // velden en methoden } ... // probeer een object te maken Taal // gooit een fout Taal obj = new Taal();

Een abstracte klasse mag zowel concrete (gewone) methoden als abstracte methoden bevatten. Bijvoorbeeld,

abstract class Taal { // abstracte methode abstract void methode1(); // gewone methode void methode2() { System.out.println("Dit is een gewone methode"); } }

Meer over gewone methoden vind je bij Java methoden.

Java abstracte methode

Een abstracte methode heeft geen body; het declareert een contract dat subklassen moeten vervullen. Het wordt gedefinieerd met het abstract sleutelwoord, bijv.,

abstract void toon();

Omdat het geen body heeft, eindigt de statement met een puntkomma. Als een klasse een abstracte methode declareert, moet de klasse zelf abstract gedeclareerd worden, anders gooit de compiler een fout:

// fout // klasse moet abstract zijn class Taal { // abstracte methode abstract void methode1(); }

Voorbeeld: Java abstracte klasse en methode

Hoewel abstracte klassen niet direct geïnstantieerd kunnen worden, kunnen concrete subklassen ze uitbreiden en hun leden gebruiken. Bijvoorbeeld,

abstract class Taal { public void toon() { System.out.println("Dit is Java Programmeren"); } } class Main extends Taal { public static void main(String[] args) { Main obj = new Main(); obj.toon(); } }

Uitvoer

Dit is Java programmeren

Hier definieert de abstracte klasse Taal een concrete methode toon(). De subklasse Main erft die methode en roept hem aan via zijn instantie.

Abstracte methoden implementeren

Wanneer een abstracte klasse een abstracte methode declareert, moet elke concrete subklasse een implementatie leveren. Bijvoorbeeld,

abstract class Dier { abstract void maakGeluid(); public void eet() { System.out.println("Ik kan eten."); } } class Hond extends Dier { public void maakGeluid() { System.out.println("Blaf blaf"); } } class Main { public static void main(String[] args) { Hond d1 = new Hond(); d1.maakGeluid(); d1.eet(); } }

Uitvoer

Blaf blaf Ik kan eten.

De subklasse Hond implementeert de abstracte maakGeluid() methode, terwijl hij de concrete eet() methode erft.

Let op: Als Hond maakGeluid() niet overrided, moet hij zelf abstract gedeclareerd worden.

Constructor van abstracte klassen benaderen

Abstracte klassen kunnen constructors definiëren net als gewone klassen. Subklassen roepen de superklasse constructor aan met super(). Bijvoorbeeld,

abstract class Dier { Dier() { // initialisatielogica } } class Hond extends Dier { Hond() { super(); // additionele initialisatie } }

Onthoud dat super() de eerste statement in de subklasse constructor moet zijn.

Java abstractie

Abstracte klassen en methoden zijn de primaire tools voor het bereiken van abstractie in Java. Abstractie verbergt onnodige implementatiedetails, presentereert alleen de essentiële interface aan de gebruiker. Dit vereenvoudigt complexe systemen en bevordert flexibiliteit.

Bijvoorbeeld, een motorfiets-rem voert dezelfde high-level functie uit – de fiets vertragen – terwijl het interne mechanisme kan verschillen per model.

Voorbeeld 3: Java abstractie

abstract class MotorFiets { abstract void rem(); } class SportFiets extends MotorFiets { public void rem() { System.out.println("SportFiets Rem"); } } class MountainFiets extends MotorFiets { public void rem() { System.out.println("MountainFiets Rem"); } } class Main { public static void main(String[] args) { MountainFiets m1 = new MountainFiets(); m1.rem(); SportFiets s1 = new SportFiets(); s1.rem(); } }

Uitvoer

MountainFiets Rem SportFiets Rem

Elke concrete subklasse levert zijn eigen rem() implementatie, wat illustreert hoe abstractie interface van implementatie ontkoppelt.

Let op: Interfaces kunnen ook gebruikt worden om abstractie in Java te bereiken.

Belangrijke punten om te onthouden

• Gebruik het abstract sleutelwoord om abstracte klassen en methoden te declareren.
• Een abstracte methode heeft geen body; het eindigt met een puntkomma.
• Klassen die abstracte methoden bevatten, moeten zelf abstract zijn.
• Abstracte klassen kunnen niet direct geïnstantieerd worden.
• Concrete subklassen erven abstracte klassen en leveren implementaties voor abstracte methoden.
• Subklassen moeten alle abstracte methoden overriden tenzij ze abstract gedeclareerd zijn.
• Static leden van een abstracte klasse kunnen benaderd worden via de klassenaam:

  Dier.statischMethode();