Klíčové slovo abstract se používá k dosažení abstrakce v Javě. Je to nepřístupový modifikátor, který se používá k vytvoření abstraktní třídy a metody.

Role abstraktní třídy je obsahovat abstraktní metody. Může však obsahovat i neabstraktní metody. Metoda, která je deklarována s klíčovým slovem abstract a nemá žádnou implementaci, je známá jako abstraktní metoda.

Syntax:-

 abstract class Employee { abstract void work(); } 

Poznámka - Nemůžeme deklarovat abstraktní metody v neabstraktní třídě.

Pravidla abstraktního klíčového slova

ne

• Abstraktní klíčové slovo nelze použít s proměnnými a konstruktory.
• Pokud je třída abstraktní, nelze ji konkretizovat.
• Pokud je metoda abstraktní, neobsahuje tělo.
• Nemůžeme použít abstraktní klíčové slovo s finále .
• Abstraktní metody nemůžeme prohlásit za soukromé .
• Abstraktní metody nemůžeme prohlásit za statický .
• Abstraktní metodu nelze synchronizovat.

Udělej to

• Abstraktní klíčové slovo lze použít pouze s třídou a metodou.
• Abstraktní třída může obsahovat konstruktory a statické metody.
• Pokud třída rozšiřuje abstraktní třídu, musí také implementovat alespoň jednu z abstraktních metod.
• Abstraktní třída může obsahovat hlavní metodu a konečnou metodu.
• Abstraktní třída může obsahovat přetížené abstraktní metody.
• Místní vnitřní třídu můžeme deklarovat jako abstraktní.
• Abstraktní metodu můžeme deklarovat pomocí klauzule throw.

Příklady abstraktního klíčového slova

Příklad 1: Abstraktní třída obsahující abstraktní metodu

 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(); } } 

Výstup:

 Bike is running 

Příklad 2: Abstraktní třída obsahující abstraktní a neabstraktní metodu

 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(); } } 

Výstup:

 Bike is running Car is running 

Příklad 3: Abstraktní třída obsahující konstruktor

 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(); } } 

Výstup:

 Constructor is invoked 

Příklad 4: Abstraktní třída obsahující přetížené abstraktní metody

 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'); } } 

Výstup:

 abstract method is invoked overloaded abstract method is invoked 

Příklad 5: Vnitřní abstraktní třída

 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(); } } 

Výstup:

 inner abstract class is invoked 

Příklad 6: Vnořená abstraktní třída

 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(); } } 

Výstup:

 nested abstract class is invoked