TechCodeview

Le mot-clé abstract est utilisé pour réaliser l'abstraction en Java. Il s'agit d'un modificateur de non-accès qui est utilisé pour créer une classe et une méthode abstraites.

Le rôle d'une classe abstraite est de contenir des méthodes abstraites. Cependant, il peut également contenir des méthodes non abstraites. La méthode déclarée avec le mot-clé abstract et qui n’a aucune implémentation est appelée méthode abstraite.

Syntaxe:-

 abstract class Employee { abstract void work(); } 

Remarque - Nous ne pouvons pas déclarer de méthodes abstraites dans une classe non abstraite.

Règles du mot-clé abstrait

À ne pas faire

• Un mot-clé abstrait ne peut pas être utilisé avec des variables et des constructeurs.
• Si une classe est abstraite, elle ne peut pas être instanciée.
• Si une méthode est abstraite, elle ne contient pas le corps.
• Nous ne pouvons pas utiliser le mot-clé abstract avec le final .
• Nous ne pouvons pas déclarer de méthodes abstraites comme privé .
• Nous ne pouvons pas déclarer de méthodes abstraites comme statique .
• Une méthode abstraite ne peut pas être synchronisée.

À faire

• Un mot-clé abstrait ne peut être utilisé qu'avec une classe et une méthode.
• Une classe abstraite peut contenir des constructeurs et des méthodes statiques.
• Si une classe étend la classe abstraite, elle doit également implémenter au moins une des méthodes abstraites.
• Une classe abstraite peut contenir la méthode principale et la méthode finale.
• Une classe abstraite peut contenir des méthodes abstraites surchargées.
• Nous pouvons déclarer la classe interne locale comme abstraite.
• Nous pouvons déclarer la méthode abstraite avec une clause throw.

Exemples de mots-clés abstraits

Exemple 1 : Classe abstraite contenant la méthode abstraite

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

Sortir:

 Bike is running 

Exemple 2 : Classe abstraite contenant la méthode abstraite et non abstraite

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

Sortir:

variable de référence en Java

 Bike is running Car is running 

Exemple 3 : Classe abstraite contenant le constructeur

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

Sortir:

 Constructor is invoked 

Exemple 4 : Classe abstraite contenant des méthodes abstraites surchargées

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

Sortir:

 abstract method is invoked overloaded abstract method is invoked 

Exemple 5 : classe abstraite interne

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

Sortir:

 inner abstract class is invoked 

Exemple 6 : classe abstraite imbriquée

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

Sortir:

 nested abstract class is invoked