Dans la programmation orientée objet, l'abstraction est définie comme cachant les détails inutiles (implémentation) à l'utilisateur et se concentrant sur les détails essentiels (fonctionnalité). Cela augmente l’efficacité et réduit ainsi la complexité.
En Java, l'abstraction peut être réalisée en utilisant cours abstraits et les méthodes. Dans ce tutoriel, nous découvrirons les méthodes abstraites et leur utilisation en Java.
Classe abstraite
Une classe est déclarée abstraite en utilisant le abstrait mot-clé. Il peut avoir zéro ou plusieurs méthodes abstraites et non abstraites. Nous devons étendre la classe abstraite et implémenter ses méthodes. Il ne peut pas être instancié.
Syntaxe de la classe abstraite :
abstract class class_name { //abstract or non-abstract methods } Remarque : Une classe abstraite peut contenir ou non des méthodes abstraites.
Méthode abstraite
Une méthode déclarée à l'aide du abstrait Un mot-clé au sein d’une classe abstraite et qui n’a pas de définition (implémentation) est appelé une méthode abstraite.
Lorsque nous avons besoin uniquement de la déclaration de méthode dans une super classe, cela peut être réalisé en déclarant les méthodes comme abstraites.
La méthode abstraite est également appelée responsabilité de sous-classe car elle n’a pas d’implémentation dans la super classe. Par conséquent, une sous-classe doit la remplacer pour fournir la définition de la méthode.
Syntaxe de la méthode abstraite :
abstract return_type method_name( [ argument-list ] );
Ici, la méthode abstraite n’a pas de corps de méthode. Il peut avoir zéro ou plusieurs arguments.
Points à retenir
Les points suivants sont les règles importantes pour la méthode abstraite en Java :
- Une méthode abstraite n'a pas de corps (implémentation), elle a juste une signature de méthode (déclaration). La classe qui étend la classe abstraite implémente les méthodes abstraites.
- Si une classe non abstraite (concrète) étend une classe abstraite, alors la classe doit implémenter toutes les méthodes abstraites de cette classe abstraite. Sinon, la classe concrète doit également être déclarée abstraite.
- Comme les méthodes abstraites n’ont que la signature, celle-ci doit avoir un point-virgule (;) à la fin.
- Voici divers combinaisons illégales d'autres modificateurs pour les méthodes par rapport à abstrait modificateur:
- final
- abstrait natif
- abstrait synchronisé
- abstrait statique
- abstrait privé
- résumé strictfp
- Si une classe contient une méthode abstraite, elle doit être abstraite et vice versa n'est pas vrai.
Exemple de méthode abstraite en Java
Exemple 1:
Dans l'exemple suivant, nous apprendrons comment l'abstraction est réalisée à l'aide de classes abstraites et de méthodes abstraites.
AbstractMethodEx1.java
// abstract class abstract class Multiply { // abstract methods // sub class must implement these methods public abstract int MultiplyTwo (int n1, int n2); public abstract int MultiplyThree (int n1, int n2, int n3); // regular method with body public void show() { System.out.println ('Method of abstract class Multiply'); } } // Regular class extends abstract class class AbstractMethodEx1 extends Multiply { // if the abstract methods are not implemented, compiler will give an error public int MultiplyTwo (int num1, int num2) { return num1 * num2; } public int MultiplyThree (int num1, int num2, int num3) { return num1 * num2 * num3; } // main method public static void main (String args[]) { Multiply obj = new AbstractMethodEx1(); System.out.println ('Multiplication of 2 numbers: ' + obj.MultiplyTwo (10, 50)); System.out.println ('Multiplication of 3 numbers: ' + obj.MultiplyThree (5, 8, 10)); obj.show(); } } Sortir:
Exemple 2 :
Par défaut, toutes les méthodes d'une interface sont publiques et abstraites. Une interface ne peut pas contenir de méthodes concrètes, c'est-à-dire des méthodes régulières avec un corps.
AbstractMethodEx2.java
// interface interface SquareCube { // abstract methods public abstract int squareNum (int n); // it not necessary to add public and abstract keywords // as the methods in interface are public abstract by default int cubeNum (int n); // regular methods are not allowed in an interface // if we uncomment this method, compiler will give an error /*public void disp() { System.out.println ('I will give error if u uncomment me'); } */ } public class AbstractMethodEx2 implements SquareCube { // defining the abstract methods of interface public int squareNum (int num) { return num * num; } public int cubeNum (int num) { return num * num * num; } // main method public static void main(String args[]){ SquareCube obj = new AbstractMethodEx2(); System.out.println('Square of number is: ' + obj.squareNum (7) ); System.out.println('Cube of number is: ' + obj.cubeNum (7)); } } Sortir:
De cette façon, nous avons découvert la méthode abstraite et son implémentation en Java.