Det abstrakta nyckelordet används för att uppnå abstraktion i Java. Det är en icke-åtkomstmodifierare som används för att skapa abstrakt klass och metod.

En abstrakt klasss roll är att innehålla abstrakta metoder. Det kan dock också innehålla icke-abstrakta metoder. Metoden som deklareras med abstrakt nyckelord och inte har någon implementering är känd som en abstrakt metod.

Syntax:-

 abstract class Employee { abstract void work(); } 

Notera - Vi kan inte deklarera abstrakta metoder i icke-abstrakt klass.

Regler för abstrakt sökord

Gör inte det

• Ett abstrakt nyckelord kan inte användas med variabler och konstruktorer.
• Om en klass är abstrakt kan den inte instansieras.
• Om en metod är abstrakt innehåller den inte kroppen.
• Vi kan inte använda det abstrakta nyckelordet med slutlig .
• Vi kan inte deklarera abstrakta metoder som privat .
• Vi kan inte deklarera abstrakta metoder som statisk .
• En abstrakt metod kan inte synkroniseras.

Göra

• Ett abstrakt nyckelord kan endast användas med klass och metod.
• En abstrakt klass kan innehålla konstruktorer och statiska metoder.
• Om en klass utökar den abstrakta klassen måste den också implementera minst en av de abstrakta metoderna.
• En abstrakt klass kan innehålla huvudmetoden och den slutliga metoden.
• En abstrakt klass kan innehålla överbelastade abstrakta metoder.
• Vi kan förklara den lokala inre klassen som abstrakt.
• Vi kan deklarera den abstrakta metoden med en throw-sats.

Exempel på abstrakta nyckelord

Exempel 1: Abstrakt klass som innehåller den abstrakta metoden

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

Produktion:

 Bike is running 

Exempel 2: Abstrakt klass som innehåller den abstrakta och icke-abstrakta metoden

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

Produktion:

 Bike is running Car is running 

Exempel 3: Abstrakt klass som innehåller konstruktorn

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

Produktion:

 Constructor is invoked 

Exempel 4: Abstrakt klass som innehåller överbelastade abstrakta metoder

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

Produktion:

 abstract method is invoked overloaded abstract method is invoked 

Exempel 5: Inre abstrakt klass

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

Produktion:

 inner abstract class is invoked 

Exempel 6: Kapslad abstrakt klass

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

Produktion:

 nested abstract class is invoked