1. Introduction aux Concepts Abstraits

Dans le domaine de la programmation orientée objet, l’abstraction est un concept essentiel qui permet de modéliser des entités et des comportements de manière générale, sans se soucier des détails spécifiques de leur implémentation. Les méthodes abstraites, les classes abstraites et les interfaces sont des outils puissants pour créer des modèles abstraits dans Java.

2. Méthodes Abstraites

Les méthodes abstraites sont des méthodes déclarées sans implémentation. Elles servent à définir des comportements généraux qui doivent être implémentés par les classes filles.

Syntaxe :

public abstract class MaClasse {
    public abstract void maMethode();
}

Dans cet exemple, maMethode() est une méthode abstraite qui ne possède pas de corps. Les classes qui héritent de MaClasse doivent fournir une implémentation de cette méthode.

3. Classes Abstraites

Les classes abstraites sont des classes qui contiennent au moins une méthode abstraite et qui ne peuvent pas être instanciées directement. Elles servent de modèles pour d’autres classes qui en héritent.

Syntaxe :

public abstract class Vehicule {
    public abstract void demarrer();
}

Dans cet exemple, Vehicule est une classe abstraite avec une méthode abstraite demarrer(). Les classes concrètes telles que Voiture ou Moto doivent fournir une implémentation de cette méthode.

• Une classe abstraite peut contenir des méthodes abstraites (méthodes sans implémentation) ainsi que des méthodes concrètes (méthodes avec implémentation).
• Elle peut également contenir des variables d’instance et des constructeurs.
• Une classe peut hériter d’une seule classe abstraite à la fois.
• Elle est utilisée pour définir des comportements communs à plusieurs sous-classes.
• Elle peut avoir des méthodes avec implémentation, ce qui permet de fournir une implémentation par défaut pour certaines fonctionnalités.
• Exemple :

public abstract class Forme {
    // Méthode abstraite
    public abstract double calculerAire();

    // Méthode concrète
    public void afficher() {
        System.out.println("Je suis une forme.");
    }
}

4. Interfaces

Les interfaces sont des contrats définissant un ensemble de méthodes que les classes qui les implémentent doivent fournir. Elles permettent de spécifier un comportement commun à plusieurs classes, indépendamment de leur hiérarchie.

Syntaxe :

public interface Animal {
    void crier();
}

Dans cet exemple, Animal est une interface avec une méthode crier() déclarée. Les classes qui implémentent Animal doivent fournir une implémentation de cette méthode.

• Une interface ne peut contenir que des méthodes abstraites (méthodes sans implémentation) et des constantes.
• Elle ne peut pas contenir de variables d’instance ni de constructeurs.
• Une classe peut implémenter plusieurs interfaces.
• Elle est utilisée pour définir des contrats comportementaux que les classes doivent respecter.
• Elle ne contient que des signatures de méthodes, sans implémentation réelle.
• Exemple :

public interface Animal {
    // Méthode abstraite
    void crier();

    // Constante
    String TYPE = "Mammifère";
}

5. Comparaison entre Classes Abstraites et Interfaces

Les classes abstraites et les interfaces sont similaires dans le sens où elles permettent de définir des comportements abstraits. Cependant, il existe des différences importantes :

• Les classes abstraites peuvent contenir des variables membres et des méthodes avec implémentation, tandis que les interfaces ne peuvent contenir que des constantes et des méthodes abstraites.
• Une classe peut hériter d’une seule classe abstraite, mais peut implémenter plusieurs interfaces.
• Les interfaces sont utilisées pour définir des comportements contractuels, tandis que les classes abstraites sont utilisées pour définir des comportements communs et partagés entre les classes filles.

6. Exercices Pratiques

Exercice 1 : Gestion des Formes

Créez une classe Forme abstraite avec une méthode abstraite calculerAire(). Implémentez cette classe dans les classes Cercle et Rectangle pour calculer l’aire de chaque forme.

Correction

// Classe abstraite Forme
public abstract class Forme {
    // Méthode abstraite pour calculer l'aire
    public abstract double calculerAire();
}

// Classe Cercle
public class Cercle extends Forme {
    private double rayon;

    public Cercle(double rayon) {
        this.rayon = rayon;
    }

    // Implémentation de la méthode calculerAire pour un cercle
    @Override
    public double calculerAire() {
        return Math.PI * rayon * rayon;
    }
}

// Classe Rectangle
public class Rectangle extends Forme {
    private double longueur;
    private double largeur;

    public Rectangle(double longueur, double largeur) {
        this.longueur = longueur;
        this.largeur = largeur;
    }

    // Implémentation de la méthode calculerAire pour un rectangle
    @Override
    public double calculerAire() {
        return longueur * largeur;
    }
}

// Classe de test
public class Main {
    public static void main(String[] args) {
        // Création d'un cercle
        Cercle cercle = new Cercle(5);
        System.out.println("Aire du cercle : " + cercle.calculerAire());

        // Création d'un rectangle
        Rectangle rectangle = new Rectangle(4, 6);
        System.out.println("Aire du rectangle : " + rectangle.calculerAire());
    }
}

Exercice 2 : Gestion des Fruits

Créez une interface Fruit avec une méthode getNom() et une méthode getPrix(). Implémentez cette interface dans les classes Pomme et Orange.

Correction

// Interface Fruit
public interface Fruit {
    String getNom();
    double getPrix();
}

// Classe Pomme
public class Pomme implements Fruit {
    @Override
    public String getNom() {
        return "Pomme";
    }

    @Override
    public double getPrix() {
        return 1.5; // Prix arbitraire pour la pomme
    }
}

// Classe Orange
public class Orange implements Fruit {
    @Override
    public String getNom() {
        return "Orange";
    }

    @Override
    public double getPrix() {
        return 2.0; // Prix arbitraire pour l'orange
    }
}

// Classe de test
public class Main {
    public static void main(String[] args) {
        // Création d'une pomme
        Pomme pomme = new Pomme();
        System.out.println("Nom de la pomme : " + pomme.getNom());
        System.out.println("Prix de la pomme : " + pomme.getPrix());

        // Création d'une orange
        Orange orange = new Orange();
        System.out.println("Nom de l'orange : " + orange.getNom());
        System.out.println("Prix de l'orange : " + orange.getPrix());
    }
}

7. Avancé : Nouveautés dans Java

Java 8 a introduit des fonctionnalités avancées pour les interfaces, permettant d’enrichir leur flexibilité et leur utilité dans la conception logicielle. Ces nouveautés incluent les méthodes statiques, les méthodes par défaut et les méthodes privées dans les interfaces.

Méthodes Statiques dans les Interfaces :

Avant Java 8, les interfaces ne pouvaient contenir que des méthodes abstraites. Avec l’introduction des méthodes statiques dans les interfaces, il est désormais possible de définir des méthodes qui appartiennent à l’interface elle-même, et non à ses implémentations.

Exemple :

public interface Utilitaire {
    static void afficherMessage(String message) {
        System.out.println(message);
    }
}

public class Main implements Utilitaire {
    public static void main(String[] args) {
        Utilitaire.afficherMessage("Bonjour !");
    }
}

Dans cet exemple, la méthode afficherMessage() est une méthode statique définie dans l’interface Utilitaire. Elle peut être appelée directement à partir de l’interface sans nécessiter une instance de classe.

Méthodes Par Défaut dans les Interfaces :

Les méthodes par défaut permettent de fournir une implémentation par défaut pour une méthode dans une interface. Elles sont utilisées pour étendre une interface sans casser la compatibilité avec les implémentations existantes.

Exemple :

public interface Calcul {
    default double diviser(double a, double b) {
        if (b != 0) {
            return a / b;
        } else {
            return Double.NaN; // Not a Number
        }
    }
}

public class Main implements Calcul {
    public static void main(String[] args) {
        Main obj = new Main();
        System.out.println(obj.diviser(10, 2)); // Affiche : 5.0
        System.out.println(obj.diviser(10, 0)); // Affiche : NaN
    }
}

Dans cet exemple, la méthode diviser() est une méthode par défaut définie dans l’interface Calcul. Elle fournit une implémentation par défaut pour la division.

Méthodes Privées dans les Interfaces :

Les méthodes privées permettent de définir des méthodes d’aide dans les interfaces. Elles sont utilisées pour partager du code réutilisable entre les méthodes par défaut ou statiques d’une interface.

Exemple :

public interface Calcul {
    default double diviser(double a, double b) {
        return diviser(a, b, 2);
    }

    private double diviser(double a, double b, int precision) {
        if (b != 0) {
            double result = a / b;
            return Math.round(result * Math.pow(10, precision)) / Math.pow(10, precision);
        } else {
            return Double.NaN;
        }
    }
}

public class Main implements Calcul {
    public static void main(String[] args) {
        Main obj = new Main();
        System.out.println(obj.diviser(10, 3)); // Affiche : 3.33
    }
}

Dans cet exemple, la méthode diviser() fait appel à une méthode privée diviser() pour effectuer le calcul avec une précision spécifique.

Ces nouveautés dans Java 8 enrichissent considérablement les fonctionnalités des interfaces, offrant une flexibilité accrue dans la conception et la gestion du code. Elles permettent d’écrire du code plus concis et plus lisible, tout en maintenant une compatibilité ascendante avec les versions précédentes de Java.

8. Conclusion

Ce cours a fourni une introduction complète aux méthodes abstraites, aux classes abstraites et aux interfaces en Java. En comprenant ces concepts, vous serez en mesure de concevoir des modèles flexibles et extensibles pour vos applications Java.