Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java L’Abstraction

La Programmation Orientée Objet en Java : L’Abstraction

L'abstraction se réfère à la capacité de faire une classe abstraite dans POO. Une classe abstraite est une classe qui ne peut pas être instanciée. Toutes les autres fonctionnalités de la classe existent toujours, et ses champs, méthodes et constructeurs sont tous accessibles de la même manière. Vous ne pouvez pas créer une instance de la classe abstraite.

Si une classe est abstraite et ne peut pas être instanciée, la classe n'a pas beaucoup d'utilité, sauf s'il s'agit d'une sous-classe. C'est généralement la façon dont l’abstraction survient pendant la phase de conception. Une classe parent contient la fonctionnalité commune d'une collection de classes enfant, mais la classe parent elle-même est trop abstraite pour être utilisée seule.

Classe abstraite

Utilisez le mot clé abstract pour déclarer une classe abstraite. Le mot clé apparaît dans la déclaration de classe quelque part avant le mot clé de class.

/* File name : 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("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }

   public void mailCheck()
   {
      System.out.println("Mailing a check to " + 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 rien n'est différent dans cette classe Employee. La classe est maintenant abstraite, mais elle possède encore trois champs, sept méthodes et un constructeur.

Maintenant, si vous essayez comme suit:

/* File name : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

Lorsque vous compilez la classe ci-dessus, vous obtiendrez l'erreur suivante:

Employee.java:46: Employee is abstract; cannot be instantiated

      Employee e = new Employee("George W.", "Houston, TX", 43);

                   ^

1 error

Etendre une classe abstraite

Nous pouvons étendre la classe Employee de manière normale comme suit:

/* File name : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double salary)
   {
       super(name, address, number);
       setSalary(salary);
   }

   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName() + " with salary " + salary);

   }

   public double getSalary()
   {
       return salary;
   }

   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }

   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Ici, nous ne pouvons pas instancier un nouvel employé, mais si nous créancions un nouvel objet Salary, l'objet Salary héritera des trois champs et sept méthodes de la classe Employee.

/* File name : 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("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

 Cela produirait 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.

 Les méthodes abstraites

Si vous souhaitez qu’une classe contienne une méthode particulière, mais que vous souhaitez que la mise en œuvre effective de cette méthode soit déterminée par des classes enfant, vous pouvez déclarer la méthode dans la classe parent comme abstraite.

Le mot clé abstract est également utilisé pour déclarer une méthode abstraite. Une méthode abstraite consiste en une signature de méthode, mais aucun corps de méthode.

La méthode abstraite n'aurait aucune définition, et sa signature est suivie d'un point-virgule, et non d’une accolade comme suit:

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
  
   public abstract double computePay();
   //Remainder of class definition
}

 Déclarer une méthode en tant que abstraite a deux résultats:

  • La classe doit également être déclarée abstraite. Si une classe contient une méthode abstraite, la classe doit également être abstraite.
  • Toute classe d'enfant doit soit remplacer la méthode abstraite, soit se déclarer abstraite.

Une classe enfant qui hérite d'une méthode abstraite doit la redéfinir. S'ils ne le font pas, ils doivent être abstraits et aucun de leurs enfants ne doit le redéfinir.

Finalement, une classe descendante doit mettre en œuvre la méthode abstraite; Sinon, vous auriez une hiérarchie de classes abstraites qui ne peuvent pas être instanciées.

Si la classe salary s'étend à la classe Employee, il est nécessaire de mettre en œuvre la méthode computePay ( ) comme suit:

/* File name : Salary.java */
public class Salary extends Employee
{
   private double salary; // Annual salary

   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   //Remainder of class definition
}

 




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java L’Abstraction