TechCodeview

Une classe déclarée avec le mot-clé abstract est appelée classe abstraite dans Java . Il peut avoir des méthodes abstraites et non abstraites (méthode avec le corps).

Avant d'apprendre la classe abstraite Java, comprenons d'abord l'abstraction en Java.

quelle est la différence entre un mégaoctet et un gigaoctet

Abstraction en Java

Abstraction est un processus consistant à masquer les détails de l'implémentation et à afficher uniquement les fonctionnalités à l'utilisateur.

D'une autre manière, il montre uniquement les éléments essentiels à l'utilisateur et masque les détails internes, par exemple l'envoi de SMS où vous tapez le texte et envoyez le message. Vous ne connaissez pas le traitement interne concernant la livraison des messages.

L'abstraction vous permet de vous concentrer sur ce que objet fait au lieu de comment il le fait.

Façons d’atteindre l’abstraction

Il existe deux façons de réaliser l'abstraction en Java

1. Classe abstraite (0 à 100%)
2. Interfaces (100%)

Classe abstraite en Java

Une classe déclarée comme abstraite est appelée classe abstraite . Il peut avoir des méthodes abstraites et non abstraites. Il doit être étendu et sa méthode mise en œuvre. Il ne peut pas être instancié.

Points à retenir

• Une classe abstraite doit être déclarée avec un mot-clé abstrait.
• Il peut avoir des méthodes abstraites et non abstraites.
• Il ne peut pas être instancié.
• Cela peut avoir constructeurs et les méthodes statiques également.
• Il peut avoir des méthodes finales qui obligeront la sous-classe à ne pas modifier le corps de la méthode.

Exemple de classe abstraite

 abstract class A{} 

Méthode abstraite en Java

Une méthode déclarée comme abstraite et qui n’a pas d’implémentation est appelée méthode abstraite.

Exemple de méthode abstraite

 abstract void printStatus();//no method body and abstract 

Exemple de classe abstraite possédant une méthode abstraite

Dans cet exemple, Bike est une classe abstraite qui contient une seule exécution de méthode abstraite. Sa mise en œuvre est assurée par la classe Honda.

Java convertit le caractère en chaîne

 abstract class Bike{ abstract void run(); } class Honda4 extends Bike{ void run(){System.out.println('running safely');} public static void main(String args[]){ Bike obj = new Honda4(); obj.run(); } } 

 running safely 

Comprendre le scénario réel de la classe Abstract

Dans cet exemple, Shape est la classe abstraite et son implémentation est assurée par les classes Rectangle et Circle.

La plupart du temps, nous ne connaissons pas la classe d'implémentation (qui est cachée pour l'utilisateur final), et un objet de la classe d'implémentation est fourni par le méthode d'usine .

UN méthode d'usine est une méthode qui renvoie l'instance de la classe. Nous découvrirons la méthode d'usine plus tard.

Dans cet exemple, si vous créez l’instance de la classe Rectangle, la méthode draw() de la classe Rectangle sera invoquée.

Fichier : TestAbstraction1.java

 abstract class Shape{ abstract void draw(); } //In real scenario, implementation is provided by others i.e. unknown by end user class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle1 extends Shape{ void draw(){System.out.println('drawing circle');} } //In real scenario, method is called by programmer or user class TestAbstraction1{ public static void main(String args[]){ Shape s=new Circle1();//In a real scenario, object is provided through method, e.g., getShape() method s.draw(); } } 

 drawing circle 

Un autre exemple de classe abstraite en Java

Fichier : TestBank.java

 abstract class Bank{ abstract int getRateOfInterest(); } class SBI extends Bank{ int getRateOfInterest(){return 7;} } class PNB extends Bank{ int getRateOfInterest(){return 8;} } class TestBank{ public static void main(String args[]){ Bank b; b=new SBI(); System.out.println('Rate of Interest is: '+b.getRateOfInterest()+' %'); b=new PNB(); System.out.println('Rate of Interest is: '+b.getRateOfInterest()+' %'); }} 

 Rate of Interest is: 7 % Rate of Interest is: 8 % 

Classe abstraite ayant un constructeur, un membre de données et des méthodes

Une classe abstraite peut avoir un membre de données, une méthode abstraite, un corps de méthode (méthode non abstraite), un constructeur et même une méthode main().

Fichier : TestAbstraction2.java

 //Example of an abstract class that has abstract and non-abstract methods abstract class Bike{ Bike(){System.out.println('bike is created');} abstract void run(); void changeGear(){System.out.println('gear changed');} } //Creating a Child class which inherits Abstract class class Honda extends Bike{ void run(){System.out.println('running safely..');} } //Creating a Test class which calls abstract and non-abstract methods class TestAbstraction2{ public static void main(String args[]){ Bike obj = new Honda(); obj.run(); obj.changeGear(); } } 

 bike is created running safely.. gear changed 

Règle : S'il existe une méthode abstraite dans une classe, cette classe doit être abstraite.

 class Bike12{ abstract void run(); } 

 compile time error 

Règle : Si vous étendez une classe abstraite qui possède une méthode abstraite, vous devez soit fournir l'implémentation de la méthode, soit rendre cette classe abstraite.

Un autre scénario réel de classe abstraite

La classe abstraite peut également être utilisée pour fournir une certaine implémentation du interface . Dans ce cas, l'utilisateur final ne peut pas être obligé de remplacer toutes les méthodes de l'interface.

Remarque : Si vous débutez avec Java, apprenez d'abord l'interface et ignorez cet exemple.

 interface A{ void a(); void b(); void c(); void d(); } abstract class B implements A{ public void c(){System.out.println('I am c');} } class M extends B{ public void a(){System.out.println('I am a');} public void b(){System.out.println('I am b');} public void d(){System.out.println('I am d');} } class Test5{ public static void main(String args[]){ A a=new M(); a.a(); a.b(); a.c(); a.d(); }} 

 Output:I am a I am b I am c I am d