Exercices corrigés Java POO – Constructeurs

// Définir la classe Cat
public class Cat {
    // Attributs privés
    private String name;
    private int age;
    // Constructeur par défaut
    public Cat() {
        // Initialiser le nom à 'Anonyme'
        this.name = "Anonyme";
        // Initialiser l'âge à 0
        this.age = 0;
    }
    // Getter pour le nom
    public String getName() {
        return name;
    }
    // Getter pour l'age
    public int getAge() {
        return age;
    }
    // Méthode principale pour tester la classe Cat
    public static void main(String[] args) {
        // Créer un nouvel objet Cat à l'aide du constructeur par 
        // défaut
        Cat c = new Cat();
        // Utiliser les méthodes getter pour accéder aux attributs
        System.out.println("Nom: "+ c.getName());
        System.out.println("Age: "+ c.getAge());
    }
}

Sortie:

Nom: Anonyme
Age: 0

Explication:

Dans l’exercice ci-dessus, le constructeur par défaut de la classe Cat fonctionne de la manière suivante :

• L’initialisation: Lorsqu’un nouvel objet Cat est créé, le constructeur par défaut est appelé automatiquement.
• Définition des valeurs par défaut: Le constructeur initialise le nom à « Anonyme » et l’âge à 0, garantissant que ces variables ont des valeurs par défaut lorsqu’un objet est créé sans valeurs spécifiques fournies.
• Encapsulation: En gardant les attributs privées et en les initialisant par le biais du constructeur, la classe garantit que les variables sont toujours définies dans un état connu lors de la création d’un objet.

// Définir la classe Car
public class Car {
    // Attributs privés
    private String name;
    private String color;

    // Constructeur paramétré
    public Car(String name, String color) {
        // Initialiser le nom avec le paramètre fourni
        this.name = name;
        // Initialiser la couleur avec le paramètre fourni
        this.color = color;
    }

    // Méthode principale pour tester la classe Car
    public static void main(String[] args) {
        // Créer un nouvel objet Car à l'aide du constructeur 
        // paramétré
        Car c = new Car("Mercedes", "Noir");
        // Afficher les valeurs des attributs
        System.out.println("Nom: " + c.name);
        System.out.println("Couleur: " + c.color);
    }
}

Sortie:

Nom: Mercedes
Couleur: Noir

Explication:

Dans l’exercice ci-dessus, le constructeur paramétré de la classe Car fonctionne de la manière suivante:

• Initialisation avec paramètres: Lorsqu’un nouvel objet Car est créé, le constructeur paramétré est appelé avec des valeurs spécifiques pour le nom et la couleur.
• Définition des valeurs: Le constructeur initialise les attributs nom et couleur avec les valeurs fournies, garantissant ainsi que l’objet est créé avec des attributs spécifiques.
• Encapsulation: En gardant les attributs privées et en les initialisant par le biais du constructeur, la classe garantit que les variables ne sont définies que lorsqu’un nouvel objet est créé, ce qui favorise une initialisation contrôlée et l’intégrité des données.

// Définir la classe Book
public class Book {
    // Attributs privés
    private String title;
    private String author;
    private double price;

    // Constructeur par défaut
    public Book() {
        // Initialiser le titre à "Inconnu"
        this.title = "Inconnu";
        // Initialiser l'auteur à "Inconnu"
        this.author = "Inconnu";
        // Initialiser le prix à 0.0
        this.price = 0.0;
    }

    // Constructeur paramétré (titre, auteur)
    public Book(String title, String author) {
        // Initialiser le titre avec le paramètre fourni
        this.title = title;
        // Initialiser l'auteur avec le paramètre fourni
        this.author = author;
        // Initialiser le prix à 0.0
        this.price = 0.0;
    }

    // Constructeur paramétré (titre, auteur, prix)
    public Book(String title, String author, double price) {
        // Initialiser le titre avec le paramètre fourni
        this.title = title;
        // Initialiser l'auteur avec le paramètre fourni
        this.author = author;
        // Initialiser le prix avec le paramètre fourni
        this.price = price;
    }

    // Méthode principale pour tester la classe Book
    public static void main(String[] args) {
        // Créer un nouvel objet Book avec le constructeur par défaut
        Book b1 = new Book();
        // Affichez les valeurs des attributs pour b1
        System.out.println("B1 Titre: " + b1.title);
        System.out.println("B1 Auteur: " + b1.author);
        System.out.println("B1 Prix: " + b1.price);

        // Créer un nouvel objet Book en utilisant le constructeur 
        // paramétré (titre, auteur)
        Book b2 = new Book("Voyage au bout de la nuit", "Louis-Ferdinand");
        // Affichez les valeurs des attributs pour b2
        System.out.println("B2 Titre: " + b2.title);
        System.out.println("B2 Auteur: " + b2.author);
        System.out.println("B2 Prix: " + b2.price);

        // Créer un nouvel objet Book en utilisant le constructeur 
        // paramétré (titre, auteur, prix)
        Book b3 = new Book("L'Étranger", "Albert Camus", 20.99);
        // Affichez les valeurs des attributs pour b3
        System.out.println("B3 Titre: " + b3.title);
        System.out.println("B3 Auteur: " + b3.author);
        System.out.println("B3 Prix: " + b3.price);
    }
}

Sortie:

B1 Titre: Inconnu
B1 Auteur: Inconnu
B1 Prix: 0.0
B2 Titre: Voyage au bout de la nuit
B2 Auteur: Louis-Ferdinand
B2 Prix: 0.0
B3 Titre: L'Étranger
B3 Auteur: Albert Camus
B3 Prix: 20.99

Explication:

Dans l’exercice ci-dessus, les constructeurs de la classe Book fonctionnent de la manière suivante :

• Constructeur par défaut : Lorsqu’un nouvel objet Book est créé sans aucun argument, le constructeur par défaut est appelé, initialisant le titre à « Inconnu », l’auteur à « Inconnu » et le prix à 0,0.
• Constructeurs paramétrés : Lorsqu’un nouvel objet Book est créé avec des valeurs spécifiques pour le titre et l’auteur, ou pour le titre, l’auteur et le prix, le constructeur paramétré correspondant est appelé, initialisant les attributs avec les valeurs fournies.
• Encapsulation : En gardant les attributs privées et en les initialisant par le biais de constructeurs, la classe garantit que les variables sont définies à des valeurs significatives lors de la création d’un objet, ce qui favorise une initialisation contrôlée et l’intégrité des données.

// Définir la classe Etudiant
public class Etudiant {
    // Attributs privés
    private int id;
    private String name;
    private String note;

    // Constructeur par défaut
    public Etudiant() {
        // Appeler le constructeur paramétré avec des valeurs par 
        // défaut
        this(0, "Anonyme", "Aucune");
    }

    // Constructeur paramétré
    public Etudiant(int id, String name, String note) {
        // Initialiser l'id avec le paramètre fourni
        this.id = id;
        // Initialiser le nom avec le paramètre fourni
        this.name = name;
        // Initialiser la note avec le paramètre fourni
        this.note = note;
    }

    // Méthode principale pour tester la classe Etudiant
    public static void main(String[] args) {
        // Créer un nouvel objet Etudiant avec le constructeur par 
        // défaut
        Etudiant e1 = new Etudiant();
        // Affichez les valeurs des attributs pour e1
        System.out.println("e1 ID: " + e1.id);
        System.out.println("e1 Nom: " + e1.name);
        System.out.println("e1 Note: " + e1.note);

        // Créer un nouvel objet Etudiant en utilisant le 
        // constructeur paramétré
        Etudiant e2 = new Etudiant(101, "Alex", "B");
        // Affichez les valeurs des attributs pour e2
        System.out.println("e2 ID: " + e2.id);
        System.out.println("e2 Nom: " + e2.name);
        System.out.println("e2 Note: " + e2.note);
    }
}

Sortie:

e1 ID: 0
e1 Nom: Anonyme
e1 Note: Aucune
e2 ID: 101
e2 Nom: Alex
e2 Note: B

Explication:

Dans l’exercice ci-dessus, les constructeurs de la classe Etudiant fonctionnent de la manière suivante :

• Le constructeur par défaut appelle le constructeur paramétré en utilisant this(0, "Anonyme", "Aucune");, ce qui garantit que toutes les attributs sont initialisées par un seul constructeur.
• Initialisation avec des paramètres: Le constructeur paramétré initialise les attributs id, name et note avec les valeurs fournies, ce qui favorise la réutilisation et la cohérence du code.
• Encapsulation: En gardant les attributs privées et en les initialisant par le biais de constructeurs, la classe garantit une initialisation contrôlée et l’intégrité des données, en encapsulant la logique de définition des valeurs par défaut dans la classe elle-même.

// Définir la classe Compte
public class Compte {
    // Attributs privés
    private String accountNumber;
    private double solde;

    // Constructeur paramétré avec validation
    public Compte(String accountNumber, double solde) {
        // Valider accountNumber
        if (accountNumber == null || accountNumber.isEmpty()) {
            // Afficher un message d'erreur si le numéro de compte 
            // est nul ou vide
            System.err.println("Erreur: Le numéro de compte ne peut pas être nul ou vide.");
            return;
        }
        // Valider solde
        if (solde < 0) {
            // Afficher un message d'erreur si le solde est négatif
            System.err.println("Erreur: le solde ne peut pas être négatif.");
            return;
        }
        // Initialiser le numéro de compte avec le paramètre fourni
        this.accountNumber = accountNumber;
        // Initialiser le solde avec le paramètre fourni
        this.solde = solde;
    }

    // Méthode principale pour tester la classe Compte
    public static void main(String[] args) {
        Compte cpt1 = new Compte("90002147", 2500.00);
        System.out.println("Numéro de compte: "+ cpt1.accountNumber);
        System.out.println("Solde: "+ cpt1.solde);

        // Test avec un numéro de compte invalide
        Compte cpt2 = new Compte("", 500.00);

        // Test avec un solde invalide
        Compte cpt3 = new Compte("90002147", -100.00);
    }
}

Sortie:

Numéro de Compte: 90002147
Solde: 2500.0
Erreur: Le numéro de Compte ne peut pas être nul ou vide.
Erreur: le solde ne peut pas être négatif.

Explication:

Dans l'exercice ci-dessus, les constructeurs de la classe Compte fonctionnent de la manière suivante :

• Constructeur paramétré avec validation : Initialise les attributs accountNumber et solde uniquement si les valeurs fournies passent les contrôles de validation. Cela permet de s'assurer que le numéro de compte n'est ni nul ni vide et que le solde n'est pas négatif.
• Encapsulation : En gardant les attributs privées et en les initialisant par le biais de constructeurs avec validation, la classe garantit une initialisation contrôlée, l'intégrité des données et une gestion appropriée des erreurs, en encapsulant la logique de définition des valeurs et d'application des contraintes au sein de la classe elle-même.

// Définir la classe Car
public class Car {
    // Attributs privés
    private String marque;
    private String model;
    private int annee;

    // Constructeur paramétré avec des valeurs par défaut
    public Car(String marque, String model, int annee) {
        // Initialiser marque avec le paramètre fourni ou une valeur 
        // par défaut
        this.marque = (marque == null || marque.isEmpty()) ? "Marque inconnue" : marque;
        // Initialiser model avec le paramètre fourni ou une valeur 
        // par défaut
        this.model = (model == null || model.isEmpty()) ? "Modèle inconnu" : model;
        // Initialiser annee avec le paramètre fourni ou une valeur 
        // par défaut
        this.annee = (annee <= 0) ? 1995 : annee;
    }

    // Méthode principale pour tester la classe Car
    public static void main(String[] args) {
        // Créer un nouvel objet Car avec des données valides
        Car c1 = new Car("Mercedes", "Class C", 2015);
        // Affichez les valeurs des attributs pour c1
        System.out.println("C1 Marque: "+ c1.marque);
        System.out.println("C1 Modèle: "+ c1.model);
        System.out.println("C1 Année: "+ c1.annee);

        // Créer un nouvel objet Car avec des données invalides
        Car c2 = new Car("", "", -1);
        // Affichez les valeurs des attributs pour c2
        System.out.println("C2 Marque: "+ c2.marque);
        System.out.println("C2 Modèle: "+ c2.model);
        System.out.println("C2 Année: "+ c2.annee);
    }
}

Sortie:

C1 Marque: Mercedes
C1 Modèle: Class C
C1 Année: 2015
C2 Marque: Marque inconnue
C2 Modèle: Modèle inconnu
C2 Année: 1995

Explication:

Dans l'exercice ci-dessus, les constructeurs de la classe Car fonctionnent de la manière suivante :

• Constructeur paramétré avec des valeurs par défaut: Initialise les attributs marque, modèle et année avec des valeurs spécifiques fournies en tant qu'arguments, ou affecte des valeurs par défaut si les arguments fournis ne sont pas valides (null, vide ou négatif).
• Encapsulation: En gardant les attributs privées et en les initialisant par le biais de constructeurs avec validation et valeurs par défaut, la classe garantit une initialisation contrôlée, l'intégrité des données et le traitement approprié des entrées non valides, en encapsulant la logique de définition des valeurs et d'application des contraintes au sein de la classe elle-même.

// Définir la classe Point
public class Point {
    // Attributs privés
    private int x;
    private int y;

    // Constructeur qui prend des paramètres int
    public Point(int x, int y) {
        // Initialiser les attributs
        this.x = x;
        this.y = y;
    }

    // Constructeur qui prend des paramètres double
    public Point(double x, double y) {
        // Initialiser les attributs en convertissant double en int
        this.x = (int) x;
        this.y = (int) y;
    }

    // Méthode pour afficher les valeurs de x et y
    public void afficherPoint() {
        System.out.println("Point (x, y): (" + x + ", " + y + ")");
    }

    // Méthode principale pour tester la classe Point
    public static void main(String[] args) {
        // Créer un objet Point à l'aide du constructeur de int
        Point p1 = new Point(6, 4);
        // Afficher les valeurs de p1
        p1.afficherPoint();

        // Créer un objet Point à l'aide du constructeur de double
        Point p2 = new Point(6.5, 4.5);
        // Afficher les valeurs de p2
        p2.afficherPoint();
    }
}

Sortie:

Point (x, y): (6, 4)
Point (x, y): (6, 4)

Explication:

Dans l'exercice ci-dessus, les constructeurs de la classe Point fonctionnent de la manière suivante :

• Les constructeurs surchargés : La présence de plusieurs constructeurs permet à la classe d'être instanciée avec différents types de paramètres (int et double), ce qui offre une certaine souplesse dans la création d'objets.
• Initialisation des données : Chaque constructeur initialise les variables d'instance x et y en fonction des paramètres fournis, démontrant ainsi le concept de surcharge des constructeurs en Java. Cela garantit que la classe Point peut gérer différents types d'entrée tout en conservant une logique d'initialisation cohérente.

// Définir la classe Salle
public class Salle {
    // Attributs privés
    private String nomdeclasse;
    private String[] etudiants;

    // Constructeur paramétré qui initialise nomdeclasse et etudiants
    public Salle(String nomdeclasse, String[] etudiants) {
        // Initialisation des attributs avec les paramètres fournis
        this.nomdeclasse = nomdeclasse;
        this.etudiants = etudiants;
    }

    // Méthode pour afficher les valeurs de nomdeclasse et etudiants
    public void afficherSalle() {
        System.out.println("Nom du classe: " + nomdeclasse);
        System.out.print("Étudiants: ");
        for (String e : etudiants) {
            System.out.print(e + " ");
        }
        System.out.println();
    }

    // Méthode principale pour tester la classe Salle
    public static void main(String[] args) {
        // Créer un tableau de noms d'étudiants
        String[] tab = {"Alex", "Ali", "Emily"};
        // Créer un objet Salle à l'aide du constructeur paramétré
        Salle s = new Salle("Biologie 101", tab);
        // Afficher les valeurs des attributs
        s.afficherSalle();
    }
}

Sortie:

Nom du classe: Biologie 101
Étudiants: Alex Ali Emily 

Explication:

Dans l'exercice ci-dessus, les constructeurs de la classe Salle fonctionnent de la manière suivante :

• Constructeur paramétré: Le constructeur Salle(String nomdeclasse, String[] etudiants) initialise les variables d'instance avec les paramètres fournis, y compris un tableau de string.
• Initialisation du tableau: En initialisant le tableau etudiants dans le constructeur, la classe peut gérer plusieurs noms d'étudiants dans le cadre de son état.
• Encapsulation: L'utilisation d'un constructeur pour initialiser les attributs garantit que la classe Salle est correctement encapsulée, avec son état (nomdeclasse et etudiants) défini au moment de la création de l'objet. Cette approche favorise l'intégrité des données et une initialisation claire des objets.

// Définir la classe Singleton
public class Singleton {
    // Variable statique privée contenant l'instance unique
    private static Singleton singleInstance = null;

    // Constructeur privé pour éviter l'instanciation
    private Singleton() {
        // Afficher un message indiquant la création de l'instance
        System.out.println("Création d'une instance Singleton.");
    }

    // Méthode statique publique permettant d'obtenir une instance 
    // unique de la classe
    public static Singleton getInstance() {
        // Si l'instance unique est nulle, créer une nouvelle 
        // instance
        if (singleInstance == null) {
            singleInstance = new Singleton();
        }
        // Retourner l'instance unique
        return singleInstance;
    }

    // Méthode principale pour tester la classe Singleton
    public static void main(String[] args) {
        // Obtenir une instance unique de Singleton
        Singleton instance1 = Singleton.getInstance();
        // Essayer d'obtenir une autre instance de Singleton
        Singleton instance2 = Singleton.getInstance();

        // Vérifier si les deux instances sont identiques
        if (instance1 == instance2) {
            System.out.println("Les deux instances sont identiques");
        } else {
            System.out.println("Les instances sont différentes.");
        }
    }
}

Sortie:

Création d'une instance Singleton.
Les deux instances sont identiques.

Explication:

Dans l'exercice ci-dessus, les constructeurs de la classe Singleton fonctionnent de la manière suivante :

• Constructeur privé : Le constructeur est privé, ce qui empêche l'instanciation de la classe depuis l'extérieur. Cela garantit qu'une seule instance de la classe peut être créée.
• Méthode statique de récupération de l'instance : La méthode getInstance() fournit un moyen contrôlé d'accéder à la seule instance de la classe. Elle vérifie si l'instance existe déjà et la crée si ce n'est pas le cas, ce qui garantit qu'une seule instance de la classe est créée.
• Contrôle de l'instance : Le pattern Singleton utilise une variable statique privée pour contenir l'instance unique, en maintenant le contrôle sur l'instanciation de la classe et en s'assurant que toutes les références à la classe pointent vers la même instance.