Exercices du chapitre 2

Solution :

public class Voiture {
    String marque;
    int annee;

    void afficherDetails() {
        System.out.println(marque + " (" + annee + ")");
    }
}

public class MainClass {
    public static void main(String[] args) {
        Voiture voiture = new Voiture();
        voiture.marque = "Dacia";
        voiture.annee = 2020;
        voiture.afficherDetails();
    }
}

Solution : le solde est private. Seules les méthodes du compte le modifient. Un montant nul ou négatif est refusé, tout comme un retrait trop grand.

public class CompteBancaire {
    private double solde;

    public void deposer(double montant) {
        if (montant <= 0) {
            System.err.println("Montant invalide");
            return;
        }
        solde = solde + montant;
    }

    public void retirer(double montant) {
        if (montant <= 0) {
            System.err.println("Montant invalide");
            return;
        }
        if (montant > solde) {
            System.err.println("Solde insuffisant");
            return;
        }
        solde = solde - montant;
    }

    public void afficherSolde() {
        System.out.println("Solde = " + solde);
    }
}

public class MainClass {
    public static void main(String[] args) {
        CompteBancaire compte = new CompteBancaire();
        compte.deposer(1000);
        compte.retirer(250);
        compte.retirer(900);
        compte.afficherSolde();
    }
}

Solution : le constructeur complet fait le travail. L’autre se contente de l’appeler en première instruction.

public class Etudiant {
    private String nom;
    private int age;

    public Etudiant(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    public Etudiant() {
        this("Inconnu", 18);
    }

    public void afficherInfos() {
        System.out.println(nom + ", " + age + " ans");
    }
}

public class MainClass {
    public static void main(String[] args) {
        Etudiant a = new Etudiant();
        Etudiant b = new Etudiant("Tazi", 22);
        a.afficherInfos();
        b.afficherInfos();
    }
}

Solution :

public class Rectangle {
    private double largeur;
    private double hauteur;

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

    public Rectangle() {
        this(1.0, 1.0);
    }

    public double calculerAire() {
        return largeur * hauteur;
    }
}

public class MainClass {
    public static void main(String[] args) {
        Rectangle r1 = new Rectangle();
        Rectangle r2 = new Rectangle(4.0, 3.0);
        System.out.println("Aire 1 = " + r1.calculerAire());
        System.out.println("Aire 2 = " + r2.calculerAire());
    }
}

Solution : nombreInstances existe une seule fois pour toute la classe. La méthode d’affichage est static, car elle ne dépend d’aucun objet précis.

public class Compteur {
    private static int nombreInstances = 0;

    public Compteur() {
        nombreInstances++;
    }

    public static void afficherNombreInstances() {
        System.out.println("Nombre d'instances : " + nombreInstances);
    }
}

public class MainClass {
    public static void main(String[] args) {
        Compteur c1 = new Compteur();
        Compteur c2 = new Compteur();
        Compteur c3 = new Compteur();
        Compteur.afficherNombreInstances();
    }
}

Solution : max et min utilisent un if. pow multiplie dans une boucle for. Pour la racine, on réutilise Math.sqrt, déjà fourni par Java dans java.lang : inutile d’écrire l’algorithme soi-même.

public class MathUtils {
    public static int max(int a, int b) {
        if (a > b) {
            return a;
        }
        return b;
    }

    public static int min(int a, int b) {
        if (a < b) {
            return a;
        }
        return b;
    }

    public static int pow(int base, int exposant) {
        if (exposant < 0) {
            System.err.println("Exposant négatif non traité");
            return 0;
        }
        int resultat = 1;
        for (int i = 0; i < exposant; i++) {
            resultat = resultat * base;
        }
        return resultat;
    }

    public static double sqrt(double valeur) {
        if (valeur < 0) {
            System.err.println("Racine d'un nombre négatif");
            return -1;
        }
        return Math.sqrt(valeur);
    }
}

public class MainClass {
    public static void main(String[] args) {
        System.out.println("max = " + MathUtils.max(8, 3));
        System.out.println("min = " + MathUtils.min(8, 3));
        System.out.println("pow = " + MathUtils.pow(2, 5));
        System.out.println("sqrt = " + MathUtils.sqrt(9));
    }
}

Solution : new Personne[3] crée le tableau, pas les personnes. Chaque case reçoit ensuite un objet avec new Personne(...).

public class Personne {
    private String nom;
    private String prenom;
    private int age;
    private static int nombrePersonnes = 0;

    public Personne(String nom, String prenom, int age) {
        this.nom = nom;
        this.prenom = prenom;
        this.age = age;
        nombrePersonnes++;
    }

    public static void afficherPopulation() {
        System.out.println("Population : " + nombrePersonnes);
    }
}

public class MainClass {
    public static void main(String[] args) {
        Personne[] groupe = new Personne[3];
        groupe[0] = new Personne("Alaoui", "Youssef", 25);
        groupe[1] = new Personne("Tazi", "Amine", 22);
        groupe[2] = new Personne("Benjelloun", "Fatima", 30);
        Personne.afficherPopulation();
    }
}

Solution : une classe publique par fichier, dans le dossier du package (vu au chapitre 1). La longueur utilise le théorème de Pythagore et Math.sqrt.

Fichier geometrie/Point.java :

package geometrie;

public class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public void afficher() {
        System.out.println("Point (" + x + ", " + y + ")");
    }
}

Fichier geometrie/Ligne.java :

package geometrie;

public class Ligne {
    private Point debut;
    private Point fin;

    public Ligne(Point debut, Point fin) {
        this.debut = debut;
        this.fin = fin;
    }

    public double longueur() {
        double dx = fin.getX() - debut.getX();
        double dy = fin.getY() - debut.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }

    public void afficher() {
        System.out.println("De (" + debut.getX() + ", " + debut.getY()
            + ") vers (" + fin.getX() + ", " + fin.getY() + ")");
        System.out.println("Longueur = " + longueur());
    }
}

Fichier application/MainClass.java :

package application;

import geometrie.Ligne;
import geometrie.Point;

public class MainClass {
    public static void main(String[] args) {
        Point a = new Point(0, 0);
        Point b = new Point(3, 4);
        Ligne ligne = new Ligne(a, b);

        a.afficher();
        b.afficher();
        ligne.afficher();
    }
}

Compilation et lancement, depuis le dossier parent de geometrie et application :

javac geometrie/*.java application/MainClass.java
java application.MainClass

Solution : trim() enlève les espaces au début et à la fin. Une boucle remplace ensuite les doubles espaces. Character.isLetter reconnaît une lettre, y compris avec accent. Si la valeur est refusée, l’attribut ne change pas.

public class Etudiant {
    private String nom;
    private double note;

    public String getNom() {
        return nom;
    }

    public double getNote() {
        return note;
    }

    public void setNom(String nom) {
        if (nom == null) {
            System.err.println("Nom invalide");
            return;
        }

        nom = nom.trim();
        while (nom.contains("  ")) {
            nom = nom.replace("  ", " ");
        }

        if (nom.isEmpty()) {
            System.err.println("Nom invalide");
            return;
        }

        for (int i = 0; i < nom.length(); i++) {
            char c = nom.charAt(i);
            if (c != ' ' && !Character.isLetter(c)) {
                System.err.println("Le nom ne doit contenir que des lettres et des espaces");
                return;
            }
        }
        this.nom = nom;
    }

    public void setNote(double note) {
        if (note < 0 || note > 20) {
            System.err.println("La note doit être entre 0 et 20");
            return;
        }
        this.note = note;
    }
}

public class MainClass {
    public static void main(String[] args) {
        Etudiant etudiant = new Etudiant();
        etudiant.setNom("  Amine   Tazi  ");
        etudiant.setNote(15.5);
        etudiant.setNote(25);

        System.out.println(etudiant.getNom());
        System.out.println(etudiant.getNote());
    }
}

Solution : la taille du tableau est la capacité de la salle pour ce film. On ne parcourt que les cases déjà remplies, de 0 à nbSpectateurs - 1 : les autres valent encore null.

public class Spectateur {
    private String nom;
    private int age;

    public Spectateur(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    public String getNom() {
        return nom;
    }

    public int getAge() {
        return age;
    }
}

public class Film {
    private String titre;
    private int duree;
    private String genre;
    private Spectateur[] spectateurs;
    private int nbSpectateurs;

    public Film(String titre, int duree, String genre, int capacite) {
        this.titre = titre;
        this.duree = duree;
        this.genre = genre;
        this.spectateurs = new Spectateur[capacite];
        this.nbSpectateurs = 0;
    }

    public String getTitre() {
        return titre;
    }

    public int getDuree() {
        return duree;
    }

    public String getGenre() {
        return genre;
    }

    public int getNbSpectateurs() {
        return nbSpectateurs;
    }

    public void ajouterSpectateur(Spectateur spectateur) {
        if (nbSpectateurs >= spectateurs.length) {
            System.err.println("Salle pleine pour " + titre);
            return;
        }
        spectateurs[nbSpectateurs] = spectateur;
        nbSpectateurs++;
    }

    public void afficherSpectateurs() {
        System.out.println(titre + " (" + duree + " min, " + genre + ")");
        if (nbSpectateurs == 0) {
            System.out.println("Aucun spectateur");
            return;
        }
        for (int i = 0; i < nbSpectateurs; i++) {
            Spectateur s = spectateurs[i];
            System.out.println("- " + s.getNom() + ", " + s.getAge() + " ans");
        }
    }
}

public class MainClass {
    public static void main(String[] args) {
        Film film = new Film("Ali Zaoua", 90, "Drame", 2);
        Spectateur amine = new Spectateur("Amine Tazi", 22);
        Spectateur fatima = new Spectateur("Fatima Benjelloun", 30);
        Spectateur youssef = new Spectateur("Youssef Alaoui", 25);

        film.ajouterSpectateur(amine);
        film.ajouterSpectateur(fatima);
        film.ajouterSpectateur(youssef);
        film.afficherSpectateurs();
    }
}