Méthode et classes abstraites Java

Les méthodes abstraites sont un outil puissant de Java et donnent à ce langage orienté objet encore plus de capacités en matière de polymorphisme. Une méthode abstraite Java peut être utilisée pour créer un cadre de base pour un programme entier et vous permettre de l'ajuster si nécessaire.

Qu'est-ce qu'une méthode abstraite ?

Une méthode abstraite est une méthode qui n'a pas d'implémentation. Autrement dit, il a juste une déclaration, vous connaissez donc le nom, le type de retour et les variables qu'il acceptera. Voici un exemple de méthode abstraite de base :

public abstract int example(int a1, int a2);

Lorsque vous regardez cette méthode, vous pouvez dire qu'elle renvoie un entier et qu'elle accepte deux entiers comme argument. Ce que vous ne pouvez pas dire, c'est comment cette méthode est implémentée. C'est parce que pour l'implémenter, vous devez le remplacer. Lors de la création d'une méthode abstraite en Java, vous devez respecter quelques directives ou votre programme ne se compilera pas correctement. Se souvenir:

• Les méthodes abstraites Java n'ont pas d'implémentation. Autrement dit, ils ne doivent jamais être suivis d'accolades et d'un corps qui indique comment la méthode doit être utilisée. Il se termine simplement par un point-virgule.

• Si vous créez une méthode abstraite, celle-ci ne peut être placée que dans une classe abstraite. Autrement dit, vous ne pouvez pas avoir une classe concrète contenant une méthode abstraite.
  je. En remarque, si vous avez une classe abstraite, elle peut contenir des constructeurs. Il n'a pas besoin d'avoir une méthode abstraite, cependant.

• Lorsqu'une classe concrète étend une classe abstraite, elle doit également implémenter toutes les méthodes abstraites de la classe parente ou elle ne peut pas être concrète et doit être déclarée abstraite.

Ces deux derniers peuvent être un peu déroutants, alors clarifions cela tout de suite.

Extension des classes Java abstraites

Disons que nous voulons écrire un programme sur les formes de base qui renverra le périmètre et l'aire. Nous créons donc une classe abstraite parente. Mais comme chaque forme a ses propres règles, chacune doit être calculée différemment, nous écrivons donc la classe abstraite Shape comme ceci :

abstract class Shape {
  		String shapeName = " ";
  		Shape(String name) { 
    			this.shapeName = name; 
  		} 

abstract double area();
  		abstract double perimeter();
}

Maintenant, si nous voulons réellement utiliser ces méthodes abstraites, nous devons étendre la classe parent Java abstraite Shape , puis instancier les méthodes. Ainsi, chaque classe concrète doit implémenter les méthodes abstraites d'aire et de périmètre.

class Quadrilateral extends Shape  
{ 
    double length, width; 
      
    Quadrilateral(double l, double w, String name) 
    { 
        super(name); 
        this.length = l; 
        this.width = w; 
    } 
      
    @Override
    public double perimeter()  
    { 
        return ((2*length)+(2*width));
    } 
      
    @Override
    public double area()  
    { 
        return (length*width); 
    } 
}

Implementing the Quadrilateral class would then look like this
class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4, "Rectangle"); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
} 

La sortie de la console ressemble alors à ceci :

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

Notez que la classe Quadrilateral n'a pas à instancier le constructeur Shape(String name) à partir de la classe parent Shape . C'est parce que ce n'est pas une méthode abstraite. Cependant, si vous implémentiez uniquement une zone ou un périmètre dans une classe, la nouvelle classe devrait être abstraite car elle n'incluait pas les deux. Vous pouvez également utiliser des méthodes abstraites dans Interfaces.

Méthodes Java abstraites avec interfaces

Passons rapidement en revue ce qu'est une interface et en quoi elle diffère d'une classe abstraite. Dans une interface, toutes les variables déclarées dans une interface sont publiques, statiques et finales. Les classes abstraites, en revanche, n'ont que des variables non finales. Tout dans une interface est public par défaut. Une classe abstraite peut avoir private, protected, public, etc. Enfin, une classe n'étend pas une interface, elle l'implémente. Avant JDK 8, une interface ne pouvait contenir que des méthodes abstraites. Désormais, une interface peut avoir des méthodes par défaut et statiques. Pour cette raison, les meilleures pratiques ont abandonné l'utilisation de méthodes abstraites comme modèles extensibles et se sont concentrées sur les interfaces et leur mise en œuvre. Donc, si vous deviez créer Shape en tant qu'interface, puis l'implémenter en tant que quadrilatère, ça ressemblerait à quoi ? Tout d'abord, vous devez supprimer le constructeur Shape (String name) . Cela ressemblerait à ceci avec seulement les deux méthodes abstraites :

interface Shape {

  abstract double area();
  abstract double perimeter();
}


So the Quadrilateral class would then look like this:
class Quadrilateral implements Shape {  

  double length, width; 
      
    	  Quadrilateral(double l, double w) {
    
    	    this.length = l; 
    	    this.width = w; 
    	  } 
      
    	  @Override
    	  public double perimeter() {
     
    	    return ((2*length)+(2*width));
    	  } 
      
    	  @Override
    	  public double area() {
    
   	    return (length*width); 
    	  } 
}

Enfin, l'utilisation du nouveau Quadrilatère lors de l'implémentation de l' interface Shape serait à peu près la même :

class Main
{ 
    public static void main (String[] args)  
    { 
      
        // creating a Quadrilateral object using Shape as reference 
        Shape rectangle = new Quadrilateral(3,4); 
        System.out.println("Area of rectangle is " + rectangle.area()); 
        System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
  
    } 
}

Et l'impression de la console ressemblerait à ceci :

Area of rectangle is 12.0
Perimeter of rectangle is 14.0

Si vous souhaitez en savoir plus sur les différences entre les interfaces et les classes abstraites, vous pouvez trouver plus d'informations ici.

Mais pourquoi utiliser des méthodes Java abstraites ?

Il existe de nombreuses raisons pour lesquelles les méthodes abstraites en Java sont utilisées et pourquoi vous devriez vous familiariser avec leur utilisation. Voici trois raisons rapides pour lesquelles vous devriez les utiliser lorsque cela est approprié.

1. Évitez la duplication des efforts - Revoyez notre exemple de codage ; imaginez que vous et votre équipe deviez créer des classes pour des formes autres qu'un rectangle. Combien de façons différentes pouvez-vous proposer pour concevoir cette classe ? Dix? Quinze? Et c'est un problème simple. Imaginez quelque chose de beaucoup plus complexe. Vous et votre équipe pourriez trouver cent façons. Ensuite, vous seriez confronté à la tâche ardue de les tisser ensemble dans un programme cohérent. Cela nous amène à notre point suivant : définir la mise en œuvre.

2. Les méthodes abstraites en Java permettent la définition de l'utilisation et de l'implémentation - Lorsque vous utilisez une classe ou une interface abstraite, et par conception, des méthodes abstraites, vous définissez comment d'autres personnes interagiront avec votre interface. Cela leur permet de savoir quelles variables ils doivent utiliser et à quels types de retour ils peuvent s'attendre.
   Bien qu'ils puissent les remplacer et créer des classes concrètes qui implémentent votre interface de manière unique, vous définissez toujours dans le marbre l'utilisation principale de votre code. Si quelqu'un veut implémenter Shape, il doit remplacer ou implémenter à la fois le périmètre et la zone.

3. Lisibilité et débogage - Avoir des méthodes abstraites améliorera la lisibilité de votre code. Lorsque vous écrivez une classe qui implémente une interface, vous savez ce qu'il faut rechercher. Vous savez que chaque méthode abstraite de l'interface sera dans l'implémentation, ce qui facilite la lecture et la recherche de bogues. Les méthodes abstraites ne sont que le début de l'apprentissage de l'utilisation correcte du polymorphisme en Java et dans d'autres langages orientés objet. Lorsque vous commencerez à les comprendre et à les utiliser, un tout nouveau chapitre de votre parcours de codage commencera.