Classe abstraite Java et méthode (avec exemple)

Dans ce didacticiel, nous découvrirons les classes et méthodes abstraites Java à l'aide d'exemples. Nous découvrirons également l'abstraction en Java.

Classe abstraite Java

La classe abstraite en Java ne peut pas être instanciée (nous ne pouvons pas créer d'objets de classes abstraites). Nous utilisons le abstractmot - clé pour déclarer une classe abstraite. Par exemple,

 // create an abstract class abstract class Language ( // fields and methods )… // try to create an object Language // throws an error Language obj = new Language(); 

Une classe abstraite peut avoir à la fois les méthodes régulières et les méthodes abstraites. Par exemple,

 abstract class Language ( // abstract method abstract void method1(); // regular method void method2() ( System.out.println("This is regular method"); ) )

Pour connaître les méthodes non abstraites, visitez les méthodes Java. Ici, nous allons découvrir les méthodes abstraites.

Méthode abstraite Java

Une méthode qui n'a pas de corps est connue sous le nom de méthode abstraite. Nous utilisons le même abstractmot-clé pour créer des méthodes abstraites. Par exemple,

 abstract void display();

Voici display()une méthode abstraite. Le corps de display()est remplacé par ;.

Si une classe contient une méthode abstraite, alors la classe doit être déclarée abstraite. Sinon, cela générera une erreur. Par exemple,

 // error // class should be abstract class Language ( // abstract method abstract void method1(); )

Exemple: classe et méthode abstraites Java

Bien que les classes abstraites ne puissent pas être instanciées, nous pouvons en créer des sous-classes. Nous pouvons alors accéder aux membres de la classe abstraite en utilisant l'objet de la sous-classe. Par exemple,

 abstract class Language ( // method of abstract class public void display() ( System.out.println("This is Java Programming"); ) ) class Main extends Language ( public static void main(String() args) ( // create an object of Main Main obj = new Main(); // access method of abstract class // using object of Main class obj.display(); ) )

Production

 C'est la programmation Java

Dans l'exemple ci-dessus, nous avons créé une classe abstraite nommée Language. La classe contient une méthode régulière display().

Nous avons créé la classe Main qui hérite de la classe abstraite. Notez la déclaration,

 obj.display();

Ici, obj est l'objet de la classe enfant Main. Nous appelons la méthode de la classe abstraite en utilisant l'objet obj.

Implémentation de méthodes abstraites

Si la classe abstraite inclut une méthode abstraite, toutes les classes enfants héritées de la superclasse abstraite doivent fournir l'implémentation de la méthode abstraite. Par exemple,

 abstract class Animal ( abstract void makeSound(); public void eat() ( System.out.println("I can eat."); ) ) class Dog extends Animal ( // provide implementation of abstract method public void makeSound() ( System.out.println("Bark bark"); ) ) class Main ( public static void main(String() args) ( // create an object of Dog class Dog d1 = new Dog(); d1.makeSound(); d1.eat(); ) )

Production

 Je peux manger de l'écorce.

Dans l'exemple ci-dessus, nous avons créé une classe abstraite Animal. La classe contient une méthode abstraite makeSound()et une méthode non abstraite eat().

Nous avons hérité d'une sous-classe Dog de la superclasse Animal. Ici, la sous-classe Dog fournit l'implémentation de la méthode abstraite makeSound().

Nous avons ensuite utilisé l'objet d1 de la classe Dog pour appeler les méthodes makeSound()et eat().

Remarque : Si la classe Dog ne fournit pas l'implémentation de la méthode abstraite makeSound(), Dog doit également être déclaré comme abstrait. En effet, la sous-classe Dog hérite makeSound()d'Animal.

Accède au constructeur de classes abstraites

Une classe abstraite peut avoir des constructeurs comme la classe régulière. Et, nous pouvons accéder au constructeur d'une classe abstraite à partir de la sous-classe en utilisant le supermot - clé. Par exemple,

 abstract class Animal ( Animal() (… . ) ) class Dog extends Animal ( Dog() ( super();… ) )

Ici, nous avons utilisé l' super()intérieur du constructeur de Dog pour accéder au constructeur de l'Animal.

Notez que le superdoit toujours être la première instruction du constructeur de sous-classe. Visitez le super mot-clé Java pour en savoir plus.

Abstraction Java

L'utilisation principale des classes et des méthodes abstraites est de réaliser l'abstraction en Java.

L'abstraction est un concept important de la programmation orientée objet qui nous permet de cacher les détails inutiles et d'afficher uniquement les informations nécessaires.

Cela nous permet de gérer la complexité en omettant ou en masquant des détails avec une idée plus simple et de plus haut niveau.

Un exemple pratique d'abstraction peut être les freins de moto. Nous savons ce que fait le frein. Lorsque nous appliquons le frein, la moto s'arrête. Cependant, le fonctionnement du frein nous est caché.

Le principal avantage de masquer le fonctionnement du frein est que maintenant le fabricant peut implémenter le frein différemment pour différentes motos, mais ce que fait le frein sera le même.

Prenons un exemple qui nous aide à mieux comprendre l'abstraction Java.

Exemple 3: abstraction Java

 abstract class Animal ( abstract void makeSound(); ) class Dog extends Animal ( // implementation of abstract method public void makeSound() ( System.out.println("Bark bark."); ) ) class Cat extends Animal ( // implementation of abstract method public void makeSound() ( System.out.println("Meows "); ) ) class Main ( public static void main(String() args) ( Dog d1 = new Dog(); d1.makeSound(); Cat c1 = new Cat(); c1.makeSound(); ) )

Sortie :

 Écorce d'écorce Meows

In the above example, we have created a superclass Animal. The superclass Animal has an abstract method makeSound().

The makeSound() method cannot be implemented inside Animal. It is because every animal makes different sounds. So, all the subclasses of Animal would have different implementation of makeSound().

So, the implementation of makeSound() in Animal is kept hidden.

Here, Dog makes its own implementation of makeSound() and Cat makes its own implementation of makeSound().

Note: We can also use interfaces to achieve abstraction in Java. To learn more, visit Java Interface.

Key Points to Remember

• We use the abstract keyword to create abstract classes and methods.
• An abstract method doesn't have any implementation (method body).
• Une classe contenant des méthodes abstraites doit également être abstraite.
• Nous ne pouvons pas créer d'objets d'une classe abstraite.
• Pour implémenter les fonctionnalités d'une classe abstraite, nous en héritons des sous-classes et créons des objets de la sous-classe.
• Une sous-classe doit remplacer toutes les méthodes abstraites d'une classe abstraite. Cependant, si la sous-classe est déclarée abstraite, il n'est pas obligatoire de remplacer les méthodes abstraites.
• Nous pouvons accéder aux attributs et méthodes statiques d'une classe abstraite en utilisant la référence de la classe abstraite. Par exemple,

   Animal.staticMethod();