mot-clé abstrait en Java

Le mot-clé abstract en Java est utilisé pour déclarer une classe ou une méthode qui ne peut pas être instanciée directement ou qui doit être implémentée par des sous-classes, respectivement. Il s'agit d'un élément clé du mécanisme d'abstraction de Java, qui permet aux développeurs de définir des classes et des méthodes abstraites fournissant un modèle pour d'autres classes.

Utilisation

Classe abstraite

Une classe abstraite est une classe qui ne peut pas être instanciée seule et qui peut contenir des méthodes abstraites qui doivent être implémentées par les sous-classes.

Méthode abstraite

Une méthode abstraite est une méthode déclarée sans implémentation. Les sous-classes de la classe abstraite doivent fournir une implémentation de ces méthodes.

Syntax

Classe abstraite

abstract class ClassName {
    // Abstract methods
    abstract void methodName();
    
    // Concrete methods
    void concreteMethod() {
        // Method body
    }
}Propulsé par

Méthode abstraite

abstract void methodName();Propulsé par

Exemples

Exemple 1 : Classe et méthode abstraites

abstract class Animal {
    // Abstract method
    abstract void makeSound();

    // Concrete method
    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    // Implementing the abstract method
    void makeSound() {
        System.out.println("Bark");
    }
}

public class AbstractExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // Outputs: Bark
        dog.sleep();     // Outputs: Sleeping...
    }
}Propulsé par

Dans cet exemple, Animal est une classe abstraite dotée d'une méthode abstraite makeSound() et d'une méthode concrète sleep(). La classe Dog étend Animal et fournit une implémentation de la méthode makeSound().

Exemple 2 : Méthodes abstraites multiples

abstract class Shape {
    abstract void draw();
    abstract double area();
}

class Circle extends Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    void draw() {
        System.out.println("Drawing Circle");
    }

    double area() {
        return Math.PI * radius * radius;
    }
}

public class ShapeExample {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.draw(); // Outputs: Drawing Circle
        System.out.println("Area: " + circle.area()); // Outputs: Area: 78.53981633974483
    }
}Propulsé par

Ici, Shape est une classe abstraite avec deux méthodes abstraites : draw() et area(). Circle étend Shape et fournit des implémentations pour les deux méthodes abstraites.

Conseils et bonnes pratiques

• Utilisez des classes abstraites pour le code partagé: Utilisez des classes abstraites lorsque vous avez du code partagé qui doit être hérité par plusieurs sous-classes. Les classes abstraites peuvent contenir des méthodes abstraites et concrètes.
• Mise en œuvre obligatoire: Assurez-vous que toutes les méthodes abstraites d'une classe abstraite sont implémentées par ses sous-classes.
• Cannot Instantiate: N'oubliez pas que vous ne pouvez pas créer directement des instances d'une classe abstraite. Vous devez créer une instance d'une sous-classe qui implémente toutes les méthodes abstraites.
• Utilisez des méthodes abstraites pour les interfaces: Si vous avez une classe qui servira de base avec des méthodes qui doivent être surchargées, utilisez des méthodes abstraites pour appliquer ce contrat.
• Combiner avec des interfaces: Les classes abstraites peuvent implémenter des interfaces et fournir des implémentations pour certaines méthodes, tout en laissant d'autres méthodes abstraites à implémenter par les sous-classes.  

  abstract class Vehicle implements Movable {
      abstract void start();
  }Propulsé par

• Constructeur dans une classe abstraite: Les classes abstraites peuvent avoir des constructeurs, qui peuvent être appelés lors de l'instanciation d'une sous-classe.  

  abstract class Base {
      Base() {
          System.out.println("Base Constructor");
      }
  }Propulsé par

• Classes abstraites et interfaces : Utilisez des classes abstraites lorsque vous devez partager du code entre des classes étroitement liées, et utilisez des interfaces lorsque vous devez définir un contrat qui peut être mis en œuvre par n'importe quelle classe, quelle que soit sa position dans la hiérarchie des classes.
• Méthodes et champs statiques: Les classes abstraites peuvent avoir des champs et des méthodes statiques, auxquels il est possible d'accéder sans créer une instance de la classe.

abstract class Utility {
    static void printMessage() {
        System.out.println("Utility Message");
    }
}Propulsé par