Aller au contenu

Classes abstraites & interfaces en Java

Objectifs et prérequis du TP sur les classes abstraites et interfaces en Java Objectifs Ce TP sur les classes abstraites et interfaces en Java a pour but d'apprendre aux étudiants à utiliser ces concepts fondamentaux de la programmation orientée objet. À la fin de ce TP, vous devriez être capable de : Définir et utiliser des classes abstraites. Créer et implémenter des interfaces.

D'après le document Classes abstraites & interfaces en Java

Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.

Document source

Objectifs et prérequis du TP sur les classes abstraites et interfaces en Java

Objectifs

Ce TP sur les classes abstraites et interfaces en Java a pour but d'apprendre aux étudiants à utiliser ces concepts fondamentaux de la programmation orientée objet. À la fin de ce TP, vous devriez être capable de :

  • Définir et utiliser des classes abstraites.
  • Créer et implémenter des interfaces.
  • Comprendre la différence entre classes abstraites et interfaces.
  • Identifier et corriger les erreurs courantes liées à ces concepts.

Prérequis

Pour réaliser ce TP, il est nécessaire d'avoir une connaissance de base de Java, notamment :

  • Compréhension des classes et objets.
  • Connaissance des méthodes et des attributs.
  • Un environnement de développement Java configuré (comme Eclipse ou IntelliJ IDEA).

Création de classes abstraites et interfaces pas à pas

Définir une classe abstraite

Commencez par définir une classe abstraite. Par exemple, nous allons créer une classe abstraite appelée Graphique qui contiendra des méthodes et des attributs communs à toutes les formes géométriques.

abstract class Graphique {
    private int x, y;

    Graphique(int x, int y) {
        this.x = x;
        this.y = y;
    }

    void affiche() {
        System.out.println("Le centre de l’objet se trouve dans: " + x + " et " + y);
    }

    abstract public double surface();
}

Créer des classes dérivées

Ensuite, vous allez créer des classes dérivées de Graphique. Par exemple, une classe Cercle et une classe Rectangle.

class Cercle extends Graphique {
    private double rayon;

    Cercle(int x, int y, int r) {
        super(x, y);
        rayon = r;
    }

    void affiche() {
        System.out.println("C’est un cercle de rayon " + rayon);
        super.affiche();
    }

    double surface() {
        return (rayon * rayon * 3.14);
    }
}

class Rectangle extends Graphique {
    private int larg, longueur;

    Rectangle(int x, int y, int l1, int l2) {
        super(x, y);
        longueur = l1;
        larg = l2;
    }

    double surface() {
        return (longueur * larg);
    }
}

Tester les classes

Pour tester les classes créées, vous allez écrire une classe de test qui instancie des objets de Cercle et Rectangle.

public class TestGraphique {
    public static void main(String[] args) {
        Graphique[] tab = new Graphique[2];
        tab[0] = new Cercle(3, 2, 7);
        tab[1] = new Rectangle(4, 7, 8, 6);

        for (Graphique g : tab) {
            g.affiche();
            System.out.println("Surface: " + g.surface());
        }
    }
}

Résultats attendus

Lorsque vous exécutez la classe de test, vous devriez obtenir une sortie similaire à celle-ci :

C’est un cercle de rayon 7
Le centre de l’objet se trouve dans: 3 et 2
Surface: 153.86
C’est un rectangle de longueur 8 et largeur 6
Le centre de l’objet se trouve dans: 4 et 7
Surface: 48

Erreurs fréquentes avec les classes abstraites et interfaces

Il existe plusieurs erreurs courantes que vous pourriez rencontrer lors de l'utilisation de classes abstraites et d'interfaces :

  • Instanciation d'une classe abstraite : Vous ne pouvez pas créer d'objets d'une classe abstraite. Par exemple, Graphique g = new Graphique(3, 2); provoquera une erreur.
  • Oubli de redéfinir une méthode abstraite : Si une classe dérivée ne redéfinit pas toutes les méthodes abstraites, elle doit être déclarée abstraite.
  • Conflits de noms : Lorsque plusieurs interfaces ont des méthodes avec le même nom, vous devez les implémenter correctement pour éviter les erreurs de compilation.

Questions fréquentes

Quelle est la différence entre une classe abstraite et une interface ?

Une classe abstraite peut contenir des méthodes concrètes et des attributs, tandis qu'une interface ne peut contenir que des méthodes abstraites et des constantes. De plus, une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d'une seule classe abstraite.

Comment définir une méthode abstraite ?

Une méthode abstraite est définie dans une classe abstraite sans corps. Elle doit être déclarée avec le mot clé abstract et doit avoir une signature. Par exemple : public abstract void m(int n);

Peut-on instancier une classe abstraite ?

Non, il n'est pas possible d'instancier une classe abstraite. Vous devez créer une classe dérivée qui implémente toutes les méthodes abstraites pour pouvoir créer des objets.

Qu'est-ce qu'une interface en Java ?

Une interface en Java est un contrat qui définit un ensemble de méthodes que les classes doivent implémenter. Les méthodes d'une interface sont par défaut abstraites et publiques.

Partager

Commentaires

Aucun commentaire pour le moment. Posez la première question.

Les commentaires sont relus avant publication. Votre e-mail n'est jamais affiché.

← Toutes les révisions