Classes abstraites Java

Dans les concepts orientés objet, tous les objets sont décrits au moyen de classes, mais inversement, toutes les classes ne servent pas à décrire des objets. Si une classe ne contient pas suffisamment d'informations pour décrire un objet spécifique, une telle classe est une classe abstraite.

Excepté que les classes abstraites ne peuvent pas instancier d'objets, les autres fonctions de la classe existent toujours. Les variables membres, les méthodes membres et les constructeurs ont les mêmes modes d'accès que les classes ordinaires.

Parce que les classes abstraites ne peuvent pas instancier d'objets, les classes abstraites doivent être héritées pour pouvoir être utilisées. Pour cette raison, il est généralement décidé lors de la phase de conception s'il faut concevoir une classe abstraite.

La classe parente contient les méthodes communes de l'ensemble des sous-classes, mais comme la classe parente elle-même est abstraite, ces méthodes ne peuvent pas être utilisées.

En Java, les classes abstraites représentent une relation d'héritage. Une classe ne peut hériter que d'une seule classe abstraite, mais une classe peut implémenter plusieurs interfaces.

Classes abstraites

Dans le langage Java, utilisez abstract class pour définir une classe abstraite. Exemple comme suit :

Code du fichier Employee.java :

/*Nom du fichier : Employee.java*/ public abstract class Employee { private String name; private String address; private int number; public Employee(String name, String address, int number) { System.out.println("Construction d'un Employee"); this.name = name; this.address = address; this.number = number; } public double computePay() { System.out.println("À l'intérieur de Employee computePay"); return 0.0; } public void mailCheck() { System.out.println("Envoi d'un chèque à " + this.name + " " + this.address); } public String toString() { return name + " " + address + " " + number; } public String getName() { return name; } public String getAddress() { return address; } public void setAddress(String newAddress) { address = newAddress; } public int getNumber() { return number; } }

Notez que cette classe Employee n'est pas différente. Bien que cette classe soit une classe abstraite, elle possède toujours 3 variables membres, 7 méthodes membres et 1 constructeur. Maintenant, si vous essayez l'exemple suivant :

Code du fichier AbstractDemo.java :

/*Nom du fichier : AbstractDemo.java*/ public class AbstractDemo { public static void main(String [] args) { /*Ce qui suit n'est pas autorisé et causera une erreur*/ Employee e = new Employee("George W.", "Houston, TX", 43); System.out.println("\n Appeler mailCheck en utilisant la référence Employee--"); e.mailCheck(); } }

Lorsque vous essayez de compiler la classe AbstractDemo, l'erreur suivante sera produite :

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Héritage des classes abstraites

Nous pouvons hériter des propriétés de la classe Employee de la manière suivante :

Code du fichier Salary.java :

/*Nom du fichier : Salary.java*/ public class Salary extends Employee { private double salary; //Salaire annuel public Salary(String name, String address, int number, double salary) { super(name, address, number); setSalary(salary); } public void mailCheck() { System.out.println("Dans mailCheck de la classe Salary "); System.out.println("Envoi du chèque à " + getName() + " avec le salaire " + salary); } public double getSalary() { return salary; } public void setSalary(double newSalary) { if(newSalary >= 0.0) { salary = newSalary; } } public double computePay() { System.out.println("Calcul de la paie pour " + getName()); return salary/52; } }

Bien que nous ne puissions pas instancier un objet de la classe Employee, si nous instancions un objet de la classe Salary, cet objet héritera de 7 méthodes membres de la classe Employee, et grâce à ces méthodes, les trois variables membres peuvent être définies ou obtenues.

Code du fichier AbstractDemo.java :

/*Nom du fichier : AbstractDemo.java*/ public class AbstractDemo { public static void main(String [] args) { Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00); Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00); System.out.println("Appeler mailCheck en utilisant la référence Salary --"); s.mailCheck(); System.out.println("\n Appeler mailCheck en utilisant la référence Employee--"); e.mailCheck(); } }

Le programme ci-dessus se compile et s'exécute avec le résultat suivant :

Constructing an Employee
Constructing an Employee
Call mailCheck using  Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.

Méthodes abstraites

Si vous voulez concevoir une telle classe qui contient une méthode membre spéciale dont l'implémentation spécifique est déterminée par ses sous-classes, alors vous pouvez déclarer cette méthode comme méthode abstraite dans la classe parente.

Le mot-clé Abstract peut également être utilisé pour déclarer des méthodes abstraites. Une méthode abstraite contient uniquement un nom de méthode et n'a pas de corps de méthode.

Une méthode abstraite n'est pas définie ; le nom de la méthode est directement suivi d'un point-virgule au lieu d'accolades.

public abstract class Employee { private String name; private String address; private int number; public abstract double computePay(); //Reste du code }

Déclarer une méthode abstraite entraîne les deux conséquences suivantes :

  • Si une classe contient une méthode abstraite, alors la classe doit être une classe abstraite.
  • Toute sous-classe doit redéfinir la méthode abstraite de la classe parente, ou se déclarer comme une classe abstraite.

Une sous-classe qui hérite d’une méthode abstraite doit redéfinir cette méthode. Sinon, la sous-classe doit également être déclarée comme une classe abstraite. Finalement, il doit exister une sous-classe qui implémente la méthode abstraite ; sinon, de la classe parente d’origine à la sous-classe finale, aucune d’elles ne peut être utilisée pour instancier des objets.

Si la classe Salary hérite de la classe Employee, alors elle doit implémenter la méthode computePay() :

Code du fichier Salary.java :

/*Nom du fichier : Salary.java*/ public class Salary extends Employee { private double salary; // Salaire annuel public double computePay() { System.out.println("Calcul de la paie pour " + getName()); return salary/52; } //Reste du code }

Règles récapitulatives des classes abstraites

  • 1. Les classes abstraites ne peuvent pas être instanciées (une erreur que les débutants commettent souvent). Si elles sont instanciées, une erreur sera signalée et la compilation échouera. Seules les sous-classes non abstraites d’une classe abstraite peuvent créer des objets.

  • 2. Une classe abstraite ne contient pas nécessairement de méthodes abstraites, mais une classe comportant des méthodes abstraites doit être une classe abstraite.

  • 3. Les méthodes abstraites dans une classe abstraite ne sont que des déclarations et ne contiennent pas de corps de méthode, ce qui signifie que l'implémentation spécifique de la méthode, c'est-à-dire la fonctionnalité spécifique de la méthode, n'est pas fournie.

  • 4. Les constructeurs et les méthodes de classe (méthodes modifiées avec static) ne peuvent pas être déclarés comme des méthodes abstraites.

  • 5. Une sous-classe d'une classe abstraite doit fournir des implémentations spécifiques des méthodes abstraites de la classe abstraite, à moins que la sous-classe ne soit également une classe abstraite.

Autres extensions