Exercice Java Corrigé – POO – Classe Abstraite

// Définir une classe abstraite nommée Animal
abstract class Animal {
    // Déclarer une méthode abstraite nommée faireBruit
    public abstract void faireBruit();
}

// Définir une sous-classe nommée Lion qui hérite Animal
class Lion extends Animal {
    // Surcharge de la méthode abstraite faireBruit de la classe 
    // Animal
    @Override
    public void faireBruit() {
        // Afficher "Lion rugit!" dans la console
        System.out.println("Lion rugit!");
    }
}

// Définir une sous-classe nommée Tiger qui hérite Animal
class Tiger extends Animal {
    // Surcharge de la méthode abstraite faireBruit de la classe 
    // Animal
    @Override
    public void faireBruit() {
        // Afficher "Tiger grogne!" dans la console
        System.out.println("Tiger grogne!");
    }
}

// Définir la classe Main
public class Main {
    // Méthode principale pour exécuter le programme
    public static void main(String[] args) {
        // Créer une instance de Lion et l'assigner à une référence 
        // Animal
        Animal lion = new Lion();
        // Appeler la méthode faireBruit sur l'instance de Lion
        lion.faireBruit(); // Sortie: Lion rugit!
        
        // Créer une instance de Tiger et l'assigner à une référence 
        // Animal
        Animal tiger = new Tiger();
        // Appeler la méthode faireBruit sur l'instance de Tiger
        tiger.faireBruit(); // Sortie: Tiger grogne!
    }
}

Sortie:

Lion rugit!
Tiger grogne!

Explication:

Le code ci-dessus définit une classe abstraite nommée Animal. Une classe abstraite est une classe qui ne peut pas être instanciée seule et qui doit être héritée par les sous-classes. La classe Animal contient une méthode abstraite nommée faireBruit(), ce qui signifie que toute sous-classe d’Animal doit fournir une implémentation pour la méthode faireBruit().

// Définir la classe Forme comme une classe abstraite
abstract class Forme {

    // Méthode abstraite pour récupérer la surface de la forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    public abstract double getSurface();

    // Méthode abstraite permettant d'obtenir le périmètre de la 
    // forme
    // Cette méthode doit être implémentée par toute sous-classe de 
    // Forme
    public abstract double getPerimeter();
} 


// Définir la classe Rectangle, qui hérite la classe Forme
class Rectangle extends Forme {

    // Champs privés pour stocker la longueur et la largeur du 
    // rectangle
    private double longueur;
    private double largeur;

    // Constructeur pour initialiser la longueur et la largeur du 
    // rectangle
    public Rectangle(double longueur, double largeur) {
        // Définir le champ longueur à la longueur fournie
        this.longueur = longueur; 
        // Définir le champ largeur à la largeur fournie
        this.largeur = largeur; 
    }

    // Méthode pour calculer et renvoyer la surface du rectangle
    public double getSurface() {
        // Calculer la surface en multipliant la longueur et la 
        // largeur
        return longueur * largeur; 
    }

    // Méthode pour calculer et renvoyer le périmètre du rectangle
    public double getPerimeter() {
        // Calculer le périmètre à l'aide de la formule 2 * (longueur 
        // + largeur)
        return 2 * (longueur + largeur); 
    }
}


// Définir la classe Cercle, qui hérite la classe Forme
class Cercle extends Forme {

    // Champ privé pour stocker le rayon du cercle
    private double rayon;

    // Constructeur pour initialiser le rayon du cercle
    public Cercle(double rayon) {
        // Attribuer au champ rayon le rayon fourni
        this.rayon = rayon; 
    }

    // Méthode pour calculer et renvoyer la surface du cercle
    public double getSurface() {
        // Calculer la surface en utilisant la formule π * rayon^2
        return Math.PI * rayon * rayon; 
    }

    // Méthode de calcul du périmètre du cercle
    public double getPerimeter() {
        // Calculer le périmètre en utilisant la formule 2*π*rayon
        return 2 * Math.PI * rayon; 
    }
}



// Définir la classe Triangle, qui hérite la classe Forme
class Triangle extends Forme {

    // Champs privés pour stocker les côtés du triangle
    private double c1;
    private double c2;
    private double c3;

    // Constructeur pour initialiser les côtés du triangle
    public Triangle(double c1, double c2, double c3) {
        this.c1 = c1;
        this.c2 = c2;
        this.c3 = c3;
    }

    // Méthode pour calculer et renvoyer la surface du triangle
    public double getSurface() {
        // Calculer le semi-périmètre
        double s = (c1 + c2 + c3) / 2; 
        // Calculer la surface à l'aide de la formule de Heron
        return Math.sqrt(s * (s - c1) * (s - c2) * (s - c3)); 
    }

    // Méthode pour calculer et renvoyer le périmètre du triangle
    public double getPerimeter() {
        // Calculer le périmètre en additionnant les côtés
        return c1 + c2 + c3; 
    }
}


// Définir la classe Main
public class Main {
    
    // Définir la méthode main qui est le point d'entrée du programme
    public static void main(String[] args) {
        
        // Créer un rectangle de longueur 15 et de largeur 20
        Forme rectangle = new Rectangle(15, 20);
        
        // Créer un cercle de rayon 5
        Forme circle = new Cercle(5);
        
        // Créer un triangle dont les côtés sont 5, 7 et 9
        Forme triangle = new Triangle(5, 7, 9);

        System.out.println("\nSurface et périmètre de différentes formes:");
        
        // Afficher les détails et calculs du rectangle
        System.out.println("\nRectangle:");
        System.out.println("Surface: "+ rectangle.getSurface());
        System.out.println("Périmètre: "+ rectangle.getPerimeter());

        // Afficher les détails et calculs du cercle
        System.out.println("\nCercle:");
        System.out.println("Surface: "+ circle.getSurface());
        System.out.println("Périmètre: "+ circle.getPerimeter());

        // Afficher les détails et calculs du triangle
        System.out.println("\nTriangle:");
        System.out.println("Surface: "+ triangle.getSurface());
        System.out.println("Périmètre: "+ triangle.getPerimeter());
    }
}

Sortie:

Surface et périmètre de différentes formes:

Rectangle:
Surface: 300.0
Périmètre: 70.0

Cercle:
Surface: 78.53981633974483
Périmètre: 31.41592653589793

Triangle:
Surface: 17.41228014936585
Périmètre: 21.0

// Définir la classe abstraite Animal
abstract class Animal {
    // Déclarer la méthode abstraite eat
    public abstract void eat();
    
    // Déclarer la méthode abstraite sleep
    public abstract void sleep();
}

// Définir la classe Lion qui hérite Animal
class Lion extends Animal {
    // Surcharge de la méthode eat de Animal
    @Override
    public void eat() {
        // Afficher ce que le lion mange
        System.out.println("Le lion mange de la viande.");
    }

    // Surcharge de la méthode sleep de Animal
    @Override
    public void sleep() {
        // Afficher où le lion dort
        System.out.println("Le lion dort sur la prairie.");
    }
}

// Définir la classe Tiger qui hérite Animal
class Tiger extends Animal {
    // Surcharge de la méthode eat de Animal
    @Override
    public void eat() {
        // Afficher ce que le tigre mange
        System.out.println("Le tigre mange de la viande et chasse parfois dans l'eau.");
    }

    // Surcharge de la méthode sleep de Animal
    @Override
    public void sleep() {
        // Afficher où le tigre dort
        System.out.println("Le tigre dort dans un endroit caché.");
    }
}

// Définir la classe Girafe qui hérite Animal
class Girafe extends Animal {
    // Surcharge de la méthode eat de Animal
    @Override
    public void eat() {
        // Afficher ce que la girafe mange
        System.out.println("Girafe broute de l'herbe et des feuilles.");
    }

    // Surcharge de la méthode sleep de Animal
    @Override
    public void sleep() {
        // Afficher où la girafe dort
        System.out.println("La girafe dort dans les champs.");
    }
}

// Définir la classe publique Main
public class Main {
    // Définir la méthode main
    public static void main(String[] args) {
        // Créer un nouvel objet Lion
        Lion lion = new Lion();
        // Appeler la méthode eat sur l'objet Lion
        lion.eat();
        // Appeler la méthode sleep sur l'objet Lion
        lion.sleep();
        // Afficher une ligne vide pour la séparation
        System.out.println();
        
        // Créer un nouvel objet Tiger
        Tiger tiger = new Tiger();
        // Appeler la méthode eat sur l'objet Tiger
        tiger.eat();
        // Appeler la méthode sleep sur l'objet Tiger
        tiger.sleep();
        // Afficher une ligne vide pour la séparation
        System.out.println();
        
        // Créer un nouvel objet Girafe
        Girafe girafe = new Girafe();
        // Appeler la méthode eat sur l'objet Girafe
        girafe.eat();
        // Appeler la méthode sleep sur l'objet Girafe
        girafe.sleep();
    }
}

Sortie:

Le lion mange de la viande.
Le lion dort sur la prairie.

Le tigre mange de la viande et chasse parfois dans l'eau.
Le tigre dort dans un endroit caché.

Girafe broute de l'herbe et des feuilles.
La girafe dort dans les champs.

Explication:

Dans ce programme, la classe Animal est une classe abstraite qui définit les méthodes abstraites eat() et sleep(). Les classes Lion, Tigre et Girafe étendent la classe Animal et fournissent leurs propres implémentations des méthodes eat() et sleep() en fonction de leur comportement spécifique. La classe Main démontre l’utilisation de ces classes en créant des objets de chaque sous-classe et en invoquant les méthodes eat() et sleep() en conséquence.

// Définir la classe abstraite Employee
abstract class Employee {
    // Déclarer les variables protégées pour le nom et le salaire de 
    // base
    protected String name;
    protected double baseSalary;

    // Constructeur pour initialiser le nom et le salaire de base
    public Employee(String name, double baseSalary) {
        // Définir le nom
        this.name = name; 
        // Définir le salaire de base
        this.baseSalary = baseSalary; 
    }

    // Déclarer la méthode abstraite pour calculer le salaire
    public abstract double calculerSalaire();

    // Déclarer la méthode abstraite pour afficher les informations
    // de l'employé
    public abstract void afficherInfo();
}

// Définir la classe Manager qui étend Employee
class Manager extends Employee {
    // Déclarer la variable privée pour le bonus
    private double bonus;

    // Constructeur pour initialiser le nom, le salaire de base et le 
    // bonus
    public Manager(String name, double baseSalary, double bonus) {
        // Appeler le constructeur de la superclasse pour définir le 
        // nom et le salaire de base
        super(name, baseSalary);
        this.bonus = bonus; // Définir le bonus
    }

    // Surcharge de la méthode calculerSalaire de Employee
    @Override
    public double calculerSalaire() {
        // Retourner le salaire total (salaire de base + bonus)
        return baseSalary + bonus;
    }

    // Surcharge de la méthode afficherInfo de Employee
    @Override
    public void afficherInfo() {
        // Afficher le nom du manager
        System.out.println("Nom du manager: " + name);
        // Afficher le salaire de base
        System.out.println("Salaire de base: " + baseSalary +"€");
        // Afficher le bonus
        System.out.println("Bonus: "+ bonus +"€");
        // Afficher le salaire total
        System.out.println("Salaire total: "+calculerSalaire()+"€");
    }
}

// Classe Programmer qui étend la classe Employee
class Programmer extends Employee {
    // Variable privée pour stocker les heures supplémentaires
    private int overtimeHours;
    // Variable privée pour stocker le taux horaire
    private double hourlyRate;

    // Constructeur pour initialiser le nom, le salaire de base, les 
    // heures supplémentaires et le taux horaire
    public Programmer(String name, double baseSalary, int overtimeHours, double hourlyRate) {
        // Appeler le constructeur de la superclasse (Employee)
        super(name, baseSalary);
        // Définir les heures supplémentaires
        this.overtimeHours = overtimeHours;
        // Définir le taux horaire
        this.hourlyRate = hourlyRate;
    }

    // Surcharge de la méthode calculerSalaire
    @Override
    public double calculerSalaire() {
        // Calculer salaire total en ajoutant le salaire de base et
        // le produit des heures supplémentaires et du taux horaire
        return baseSalary + (overtimeHours * hourlyRate);
    }

    // Surcharge de la méthode afficherInfo
    @Override
    public void afficherInfo() {
        // Afficher le nom du programmeur
        System.out.println("Nom du programmeur: "+ name);
        // Afficher le salaire de base
        System.out.println("Salaire de base: "+ baseSalary +"€");
        // Afficher les heures supplémentaires
        System.out.println("Heures supplémentaires:"+ overtimeHours);
        // Afficher le taux horaire
        System.out.println("Taux horaire: "+ hourlyRate +"€");
        // Afficher le salaire total
        System.out.println("Salaire total: "+calculerSalaire()+"€");
    }
}

// Classe publique Main
public class Main {
    // Méthode principale
    public static void main(String[] args) {
        // Créer une instance de Manager avec le nom "Alex Chio", le 
        // salaire de base 5000 et le bonus 100
        Employee manager = new Manager("Alex Chio", 5000, 100);
        // Créer une instance de Programmer avec le nom "Antal Nuka", 
        // le salaire de base 4000, les heures supplémentaires 15 et 
        // le taux horaire 20.0
        Employee programmer = new Programmer("Bob Fio",4000,15,20.0);
        // Appeler la méthode afficherInfo sur l'instance manager
        manager.afficherInfo();
        // Afficher une ligne de séparation
        System.out.println("---------------------");
        // Appeler la méthode afficherInfo sur l'instance programmer
        programmer.afficherInfo();
    }
}

Sortie:

Nom du manager: Alex Chio
Salaire de base: 5000.0€
Bonus: 100.0€
Salaire total: 5100.0€
---------------------
Nom du programmeur: Bob Fio
Salaire de base: 4000.0€
Heures supplémentaires: 15
Taux horaire: 20.0€
Salaire total: 4300.0€

// Classe abstraite Forme3D
abstract class Forme3D {
    // Méthode abstraite pour calculer le volume
    public abstract double calculerVolume();
    
    // Méthode abstraite pour calculer la surface
    public abstract double calculerSurface();
}

// Classe Sphere qui hérite Forme3D
class Sphere extends Forme3D {
    // Variable privée pour stocker le rayon
    private double radius;

    // Constructeur pour initialiser le rayon
    public Sphere(double radius) {
        // Initialiser la valeur du rayon
        this.radius = radius;
    }

    // Surcharge de la méthode calculerVolume
    @Override
    public double calculerVolume() {
        // Calculer le volume de la sphère avec la formule (4/3) * π 
        // * rayon^3
        return (4.0 / 3.0) * Math.PI * Math.pow(radius, 3);
    }

    // Surcharge de la méthode calculerSurface
    @Override
    public double calculerSurface() {
        // Calculer la surface de la sphère avec la formule 4 * π * 
        // rayon^2
        return 4 * Math.PI * Math.pow(radius, 2);
    }
}

// Classe Cube qui hérite Forme3D
class Cube extends Forme3D {
    // Variable privée pour stocker la longueur du côté
    private double longCote;

    // Constructeur pour initialiser la longueur du côté
    public Cube(double longCote) {
        // Initialiser la valeur de la longueur du côté
        this.longCote = longCote;
    }

    // Surcharge de la méthode calculerVolume
    @Override
    public double calculerVolume() {
        // Calculer le volume du cube avec la formule côté^3
        return Math.pow(longCote, 3);
    }

    // Surcharge de la méthode calculerSurface
    @Override
    public double calculerSurface() {
        // Calculer la surface du cube avec la formule 6 * côté^2
        return 6 * Math.pow(longCote, 2);
    }
}

// Classe publique Main
public class Main {
    // Méthode principale
    public static void main(String[] args) {
        // Créer une instance de Sphere avec un rayon de 8.0
        Forme3D sphere = new Sphere(8.0);
        
        // Créer une instance de Cube avec une longueur de côté de 
        // 6.0
        Forme3D cube = new Cube(6.0);

        // Afficher le volume de la sphère
        System.out.println("Volume de la sphère: "+ sphere.calculerVolume());
        
        // Afficher la surface de la sphère
        System.out.println("Surface de la sphère: "+ sphere.calculerSurface());

        // Afficher le volume du cube
        System.out.println("Volume du cube: "+ cube.calculerVolume());

        // Afficher la surface du cube
        System.out.println("Surface du cube: "+ cube.calculerSurface());
    }
}

Sortie:

Volume de la sphère: 2144.660584850632
Surface de la sphère: 804.247719318987
Volume du cube: 216.0
Surface du cube: 216.0

// Classe abstraite Vehicule 
abstract class Vehicule {
    // Méthode abstraite pour démarrer le moteur
    public abstract void startEngine();
    
    // Méthode abstraite pour arrêter le moteur
    public abstract void stopEngine();
}

// Classe Voiture qui étend Vehicule 
class Voiture extends Vehicule {
    // Surcharge de la méthode startEngine
    @Override
    public void startEngine() {
        // Afficher un message pour indiquer le démarrage du moteur
        System.out.println("Voiture: Démarrage du moteur...");
    }

    // Surcharge de la méthode stopEngine
    @Override
    public void stopEngine() {
        // Afficher un message pour indiquer l'arrêt du moteur
        System.out.println("Voiture: Arrêt du moteur...");
    }
}

// Classe Moto qui étend Vehicule 
class Moto extends Vehicule {
    // Surcharge de la méthode startEngine
    @Override
    public void startEngine() {
        // Afficher un message pour indiquer le démarrage du moteur
        System.out.println("Moto: Démarrage du moteur...");
    }

    // Surcharge de la méthode stopEngine
    @Override
    public void stopEngine() {
        // Afficher un message pour indiquer l'arrêt du moteur
        System.out.println("Moto: Arrêt du moteur...");
    }
}

// Classe publique Main
public class Main {
    // La méthode principale, point d'entrée du programme
    public static void main(String[] args) {
        // Créer une instance de Voiture en tant que Vehicule 
        Vehicule v = new Voiture();
        
        // Créer une instance de Moto en tant que Vehicule 
        Vehicule m = new Moto();
        
        // Appeler la méthode startEngine sur l'objet v
        v.startEngine();
        
        // Appeler la méthode stopEngine sur l'objet v
        v.stopEngine();
        
        // Appeler la méthode startEngine sur l'objet m
        m.startEngine();
        
        // Appeler la méthode stopEngine sur l'objet m
        m.stopEngine();
    }
}

Sortie:

Voiture: Démarrage du moteur...
Voiture: Arrêt du moteur...
Moto: Démarrage du moteur...
Moto: Arrêt du moteur...

// Définir une classe abstraite nommée Personne
abstract class Personne {
    // Déclarer une méthode abstraite pour manger
    public abstract void manger();
    
    // Déclarer une méthode abstraite pour faire de l'exercice
    public abstract void exercice();
}

// Définir une classe nommée Athlete qui hérite la classe Personne
class Athlete extends Personne {
    // Surcharger la méthode manger de la classe Personne
    @Override
    public void manger() {
        // Afficher un message concernant le régime de l'athlète
        System.out.println("Athlète: Inclure des aliments riches en calcium, fer, potassium et fibres.");
    }

    // Surcharger la méthode exercice de la classe Personne
    @Override
    public void exercice() {
        // Afficher un message concernant l'entraînement de l'athlète
        System.out.println("Athlète: L'entraînement permet au corps de renforcer progressivement sa force et son endurance, d'améliorer les niveaux de compétence et de développer la motivation, l'ambition et la confiance.");
    }
}

// Définir une classe nommée Paresseux qui hérite la classe Personne
class Paresseux extends Personne {
    // Surcharger la méthode manger de la classe Personne
    @Override
    public void manger() {
        // Afficher un message concernant les habitudes alimentaires 
        // de la personne paresseuse
        System.out.println("Paresseux: Manger tout en regardant la télévision prolonge également la durée pendant laquelle on mange.");
    }

    // Surcharger la méthode exercice de la classe Personne
    @Override
    public void exercice() {
        // Afficher un message concernant les habitudes d'exercice de 
        // la personne paresseuse
        System.out.println("Paresseux: Rarement faire de l'exercice ou être physiquement actif.");
    }
}

// Définir la classe Main
public class Main {
    // La méthode principale, point d'entrée du programme
    public static void main(String[] args) {
        // Créer une instance de Athlete en tant que Personne
        Personne athlete = new Athlete();
        
        // Créer une instance de Paresseux en tant que Personne
        Personne paresseux = new Paresseux();
        
        // Appeler la méthode manger sur l'objet athlete
        athlete.manger();
        
        // Appeler la méthode exercice sur l'objet athlete
        athlete.exercice();
        
        // Appeler la méthode manger sur l'objet paresseux
        paresseux.manger();
        
        // Appeler la méthode exercice sur l'objet paresseux
        paresseux.exercice();
    }
}

Sortie:

Athlète: Inclure des aliments riches en calcium, fer, potassium et fibres.
Athlète: L'entraînement permet au corps de renforcer progressivement sa force et son endurance, d'améliorer les niveaux de compétence et de développer la motivation, l'ambition et la confiance.
Paresseux: Manger tout en regardant la télévision prolonge également la durée pendant laquelle on mange.
Paresseux: Rarement faire de l'exercice ou être physiquement actif.

// Définir une classe abstraite nommée Instrument
abstract class Instrument {
    // Déclarer une méthode abstraite pour jouer de l'instrument
    public abstract void play();
    
    // Déclarer une méthode abstraite pour accorder l'instrument
    public abstract void tune();
}

// Définir une classe nommée Carillon qui hérite la classe Instrument
class Carillon extends Instrument {
    // Surcharger la méthode play de la classe Instrument
    @Override
    public void play() {
        //Afficher un message concernant le fait de jouer du carillon
        System.out.println("Carillon: Jouer les notes sur les barres métalliques.");
    }

    // Surcharger la méthode tune de la classe Instrument
    @Override
    public void tune() {
        // Afficher un message concernant l'accordage du carillon
        System.out.println("Carillon: Accorder les barres métalliques à la bonne hauteur.");
    }
}

// Définir une classe nommée Violon qui hérite la classe Instrument
class Violon extends Instrument {
    // Surcharger la méthode play de la classe Instrument
    @Override
    public void play() {
        // Afficher un message concernant le fait de jouer du violon
        System.out.println("Violon: Jouer les cordes avec un archet ou les doigts.");
    }

    // Surcharger la méthode tune de la classe Instrument
    @Override
    public void tune() {
        // Afficher un message concernant l'accordage du violon
        System.out.println("Violon: Accorder les cordes à la bonne hauteur.");
    }
}

// Définir la classe Main
public class Main {
    // La méthode principale, point d'entrée du programme
    public static void main(String[] args) {
        // Créer une instance de Carillon en tant qu'Instrument
        Instrument carillon = new Carillon();
        
        // Créer une instance de Violon en tant qu'Instrument
        Instrument violon = new Violon();
        
        // Appeler la méthode play sur l'objet carillon
        carillon.play();
        
        // Appeler la méthode tune sur l'objet carillon
        carillon.tune();
        
        // Appeler la méthode play sur l'objet violon
        violon.play();
        
        // Appeler la méthode tune sur l'objet violon
        violon.tune();
    }
}

Sortie:

Carillon: Jouer les notes sur les barres métalliques.
Carillon: Accorder les barres métalliques à la bonne hauteur.
Violon: Jouer les cordes avec un archet ou les doigts.
Violon: Accorder les cordes à la bonne hauteur.

// Définir une classe abstraite nommée Forme2D
abstract class Forme2D {  

  // Déclarer une méthode abstraite dessiner
  public abstract void dessiner();  

  // Déclarer une méthode abstraite redimensionner
  public abstract void redimensionner();
} 

// Définir une classe nommée Rectangle qui hérite de Forme2D
class Rectangle extends Forme2D {  

  // Redéfinir la méthode dessiner de Forme2D
  @Override  
  // Implémentation de la méthode dessiner qui affiche un message
  public void dessiner() {    
    System.out.println("Rectangle: Dessiner un rectangle.");  
  }  

  // Redéfinir la méthode redimensionner de Forme2D
  @Override  
  // Implémentation de la méthode redimensionner qui affiche un 
  // message
  public void redimensionner() {    
    System.out.println("Rectangle: Redimensionner le rectangle.");  
  }
}

// Définir une classe nommée Cercle qui hérite de Forme2D
class Cercle extends Forme2D {  

  // Redéfinir la méthode dessiner de Forme2D
  @Override  
  // Implémentation de la méthode dessiner qui affiche un message
  public void dessiner() {    
    System.out.println("Cercle: Dessiner un cercle.");  
  }  

  // Redéfinir la méthode redimensionner de Forme2D
  @Override  
  // Implémentation de la méthode redimensionner qui affiche un 
  // message
  public void redimensionner() {    
    System.out.println("Cercle: Redimensionner le cercle.");  
  }
}

// Définir une classe publique nommée Main
public class Main {  

  // Définir la méthode main, qui est le point d'entrée du programme
  public static void main(String[] args) {    

    // Créer une instance de Rectangle et l'assigner à une référence 
    // de type Forme2D
    Forme2D rectangle = new Rectangle();    

    // Créer une instance de Cercle et l'assigner à une référence de 
    // type Forme2D
    Forme2D cercle = new Cercle();    

    // Appeler la méthode dessiner sur l'objet rectangle
    rectangle.dessiner();    

    // Appeler la méthode redimensionner sur l'objet rectangle
    rectangle.redimensionner();    

    // Appeler la méthode dessiner sur l'objet cercle
    cercle.dessiner();    

    // Appeler la méthode redimensionner sur l'objet cercle
    cercle.redimensionner();  
  }
}

Sortie:

Rectangle: Dessiner un rectangle.
Rectangle: Redimensionner le rectangle.
Cercle: Dessiner un cercle.
Cercle: Redimensionner le cercle.

// Définir une classe abstraite nommée Oiseau
abstract class Oiseau {  

  // Déclarer une méthode abstraite nommée voler
  public abstract void voler();  

  // Déclarer une méthode abstraite nommée faireSon
  public abstract void faireSon();
}

// Définir une classe nommée Aigle qui hérite de Oiseau
class Aigle extends Oiseau {  

  // Redéfinir la méthode voler de Oiseau
  @Override  
  // Implémentation de la méthode voler qui affiche un message
  public void voler() {    
    System.out.println("Aigle: Voler haut dans le ciel.");  
  }  

  // Redéfinir la méthode faireSon de Oiseau
  @Override  
  // Implémentation de la méthode faireSon qui affiche un message
  public void faireSon() {    
    System.out.println("Aigle: Cri aigu! Cri aigu!");  
  }
}

// Définir une classe nommée Faucon qui hérite de Oiseau
class Faucon extends Oiseau {  

  // Redéfinir la méthode voler de Oiseau
  @Override  
  // Implémentation de la méthode voler qui affiche un message
  public void voler() {    
    System.out.println("Faucon: Planer dans les airs.");  
  }  

  // Redéfinir la méthode faireSon de Oiseau
  @Override  
  // Implémentation de la méthode faireSon qui affiche un message
  public void faireSon() {    
    System.out.println("Faucon: Croasse! Croasse!");  
  }
}

// Définir une classe publique nommée Main
public class Main {  

  // Définir la méthode main, qui est le point d'entrée du programme
  public static void main(String[] args) {    

    // Créer une instance de Aigle et l'assigner à une référence de 
    // type Oiseau
    Oiseau aigle = new Aigle();    

    // Créer une instance de Faucon et l'assigner à une référence de 
    // type Oiseau
    Oiseau faucon = new Faucon();    

    // Appeler la méthode voler sur l'objet aigle
    aigle.voler();    

    // Appeler la méthode faireSon sur l'objet aigle
    aigle.faireSon();    

    // Appeler la méthode voler sur l'objet faucon
    faucon.voler();    

    // Appeler la méthode faireSon sur l'objet faucon
    faucon.faireSon();  
  }
}

Sortie:

Aigle: Voler haut dans le ciel.
Aigle: Cri aigu! Cri aigu!
Faucon: Planer dans les airs.
Faucon: Croasse! Croasse!