Het abstracte trefwoord wordt gebruikt om abstractie in Java te bereiken. Het is een niet-toegangsmodifier die wordt gebruikt om abstracte klassen en methoden te creëren.

De rol van een abstracte klasse is om abstracte methoden te bevatten. Het kan echter ook niet-abstracte methoden bevatten. De methode die wordt gedeclareerd met een abstract trefwoord en geen enkele implementatie heeft, staat bekend als een abstracte methode.

Syntaxis:-

 abstract class Employee { abstract void work(); } 

Opmerking - We kunnen geen abstracte methoden declareren in een niet-abstracte klasse.

Regels voor abstract trefwoord

Niet doen

• Een abstract trefwoord kan niet worden gebruikt met variabelen en constructors.
• Als een klasse abstract is, kan deze niet worden geïnstantieerd.
• Als een methode abstract is, bevat deze niet de hoofdtekst.
• We kunnen het abstracte trefwoord niet gebruiken met de laatste .
• We kunnen abstracte methoden niet declareren als privaat .
• We kunnen abstracte methoden niet declareren als statisch .
• Een abstracte methode kan niet worden gesynchroniseerd.

Doen

• Een abstract trefwoord kan alleen worden gebruikt met klasse en methode.
• Een abstracte klasse kan constructors en statische methoden bevatten.
• Als een klasse de abstracte klasse uitbreidt, moet deze ook ten minste één van de abstracte methoden implementeren.
• Een abstracte klasse kan de hoofdmethode en de uiteindelijke methode bevatten.
• Een abstracte klasse kan overbelaste abstracte methoden bevatten.
• We kunnen de lokale innerlijke klasse als abstract verklaren.
• We kunnen de abstracte methode declareren met een throw-clausule.

Voorbeelden van abstracte trefwoorden

Voorbeeld 1: Abstracte klasse die de abstracte methode bevat

 abstract class Vehicle { abstract void bike(); } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample1 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); } } 

Uitgang:

 Bike is running 

Voorbeeld 2: Abstracte klasse die de abstracte en niet-abstracte methode bevat

 abstract class Vehicle { abstract void bike(); void car() { System.out.println('Car is running'); } } class Honda extends Vehicle { @Override void bike() { System.out.println('Bike is running'); } } public class AbstractExample2 { public static void main(String[] args) { Honda obj=new Honda(); obj.bike(); obj.car(); } } 

Uitgang:

 Bike is running Car is running 

Voorbeeld 3: abstracte klasse die de constructor bevat

 abstract class Vehicle { String msg; Vehicle(String msg) { this.msg=msg; } void display() { System.out.println(msg); } } class Honda extends Vehicle { Honda(String msg) { super(msg); } } public class AbstractExample3 { public static void main(String[] args) { Honda obj=new Honda('Constructor is invoked'); obj.display(); } } 

Uitgang:

 Constructor is invoked 

Voorbeeld 4: Abstracte klasse met overbelaste abstracte methoden

 abstract class Vehicle { abstract void display(); abstract void display(String msg); } class Honda extends Vehicle { @Override void display() { System.out.println('abstract method is invoked'); } @Override void display(String msg) { System.out.println(msg); } } public class AbstractExample4 { public static void main(String[] args) { Honda obj=new Honda(); obj.display(); obj.display('overloaded abstract method is invoked'); } } 

Uitgang:

 abstract method is invoked overloaded abstract method is invoked 

Voorbeeld 5: Innerlijke abstracte klasse

 class Vehicle { abstract class Car { abstract void display(); } class Honda extends Car { @Override void display() { System.out.println('inner abstract class is invoked'); } } } public class AbstractExample5 { public static void main(String[] args) { Vehicle obj=new Vehicle(); Vehicle.Car c=obj.new Honda(); c.display(); } } 

Uitgang:

 inner abstract class is invoked 

Voorbeeld 6: Geneste abstracte klasse

 abstract class Vehicle { abstract class Car { abstract void display(); } } class Honda extends Vehicle { class FourWheller extends Car { @Override void display() { System.out.println('nested abstract class is invoked'); } } } public class AbstractExample6 { public static void main(String[] args) { Vehicle obj=new Honda(); Honda h=(Honda)obj; Honda.FourWheller fw=h.new FourWheller(); fw.display(); } } 

Uitgang:

 nested abstract class is invoked