Examen Java - test 01 / xx

EXERCICE 01 :

1) Définition: objet, classe, classe anonyme, classe enveloppe

2) Comment pouvez-vous garantir que toutes les erreurs que peut provoquer une instruction (un appel de méthode par exemple) soient traitées ?

3) Si plusieurs types d'exceptions sont traités, dans quel ordre les blocs catch doivent-ils être placés?

4) Quelle est la différence entre throw et throws ?

EXERCICE 02 :

Soit le programme suivant :

        
class ConcatIncorrecte {
    public static void main(String[] args) {
        String s = "China Blue";
        System.out.println(s);
        concat(s, " Express");
        System.out.println(s);
    }

    public static void concat(String s, String s2) {
        s += s2;
    }
}
        
    
  1. Expliquez pourquoi la méthode concatener ne parvient pas à modifier la chaîne s du main (en y concaténant " Express")
  2. Corriger le codage de la méthode concatener et son utilisation dans le main de sorte à ce que l'exécution du programme affiche :

China Blue China Blue Express

au lieu de :

China Blue China Blue

EXERCICE 03 :

Donner la sortie (écran) du programme Java suivant et expliquer :

        
public class CC2021 {

public static void g() throws Exception {

System.out.println("g:Before");

throw new Exception("Exception1");

System.out.println("g:After");

}

public static void m1() throws Exception {

try {

System.out.println("m1 Before");

g();

System.out.println("m1 After");

} catch (Exception e) {

System.out.println("m1:Catch");
throw new Exception("Exception2");

} finally {

System.out.println("m2:Finally");

}

System.out.println("m1:End");

}

public static void main(String[] args) {

m1();

System.out.println("---Fin Main ----");

}
}
        
    

EXERCICE 04 :

Écrire un programme Java qui effectue la copie d'un fichier. Ce programme prend sur la ligne de commande le nom du fichier source et le nom du fichier destination.

PROBLEME :

Votre grand-mère a besoin d'un programme Java pour gérer sa collection d'ustensiles de cuisine anciens, plus précisément des assiettes (rondes ou carrées) et des cuillères. Vous trouverez ci-dessous une version incomplète de son programme Collection. Les 5 objets créés sont stockés dans le tableau us qui est de type Ustensile[ ].

        
class Collection {
    public static void main(String[] args) {
        Ustensile[] us = new Ustensile[5];
        us[0] = new AssietteRonde(1926, 8.4);
        us[1] = new Cuillere(1881, 7.3);
        us[2] = new AssietteCarree(1935, 5.6);
        us[3] = new Cuillere(1917, 8.8);
        us[4] = new AssietteRonde(1837, 5.4);

        afficherCuilleres(us);
        afficherSurfaceAssiettes(us);
        afficherValeurTotale(us);
    }

    static void afficherCuilleres(Ustensile[] us) {
        int nbCuilleres = 0;
        for (int i = 0; i < us.length; i++) {
            // A compléter
        }
        System.out.println("Il y a " + nbCuilleres + " cuillères.");
    }

    static void afficherSurfaceAssiettes(Ustensile[] us) {
        double somme = 0;
        for (int i = 0; i < us.length; i++) {
            // A compléter
        }
        System.out.println("Surface totale des assiettes : " + somme);
    }

    static void afficherValeurTotale(Ustensile[] us) {
        double somme = 0;
        for (int i = 0; i < us.length; i++) {
            // A compléter
        }
        System.out.println("Valeur totale de la collection : " + somme);
    }
}
        
    


Il vous est demandé de compléter le programme selon les indications dans les quatre questions ci-après. Pensez à profiter au maximum des possibilités offertes par Java pour éviter la duplication inutile d'instructions dans les classes et les méthodes.

Hiérarchie de classes

Il convient de modéliser les objets de la collection avec une hiérarchie de 5 classes comme indiqué dans la liste ci-dessous. Ecrivez le code de cette hiérarchie de classes, y compris les variables d'instance et les constructeurs. Vous pouvez ajouter les nouvelles classes au fichier Collection.java, si vous voulez, ou bien utiliser des fichiers séparés.

Evitez de dupliquer inutilement des instructions. La méthode main du programme Collection ci-dessus vous montre la façon d'appeler les constructeurs des classes qui sont instanciables.

Chaque Ustensile a une annee de fabrication qui est une valeur int. Un Ustensile est soit une Assiette, soit une Cuillere. Il n'est pas possible d'instancier la classe Ustensile.

Une Assiette est soit une AssietteRonde, soit une AssietteCarree. Il n'est pas possible d'instancier la classe Assiette.

Chaque AssietteRonde à un rayon qui est une valeur double.

Chaque AssietteCarree à un cote qui est une valeur double.

Chaque Cuillere à une longueur qui est une valeur double.

Comptage

Complétez le code de la méthode afficherCuilleres pour qu'elle calcule et affiche le nombre d'objets de type Cuillere qui sont stockés dans le tableau us. Par exemple, le code de la méthode main ci-dessus donne lieu à l'affichage suivant:

Il y a 2 cuillères.

Surface totale

Complétez le code de la méthode afficherSurfaceAssiettes pour qu'elle calcule et affiche la somme des surfaces de toutes les assiettes stockées dans le tableau us, c'est-à-dire les assiettes rondes et les assiettes carrées. Il sera nécessaire de compléter la hiérarchie des classes avec des méthodes de calcul de surface. Evitez de dupliquer inutilement des instructions.

La surface d'une assiette se calcule comme suit:

AssietteRonde : 3.14 * rayon * rayon

AssietteCarree : cote * cote

Par exemple, le code de la méthode main ci-dessus donne lieu à l'affichage suivant:

Surface totale des assiettes : 344.48080000000004

CORRECTION :

EXERCICE 01 :

Objet : Un objet est une instance d'une classe dans la programmation orientée objet. Il combine des données (attributs) et des méthodes qui agissent sur ces données. Les objets sont des entités autonomes qui interagissent les unes avec les autres pour accomplir des tâches.

Classe : Une classe est un modèle pour la création d'objets. Elle définit les attributs et les méthodes communes à tous les objets d'un certain type. Les objets sont créés à partir de classes.

Classe anonyme : Une classe anonyme est une classe sans nom, souvent utilisée pour implémenter une interface ou étendre une classe abstraite de manière concise. Elle est déclarée et instanciée en même temps.

Classe enveloppe : Une classe enveloppe (wrapper class) est une classe qui encapsule, embrasse ou enveloppe un type de données primitif (comme int, char, etc.) dans un objet. Ces classes fournissent des méthodes utiles pour travailler avec des types de données primitifs dans le contexte de la programmation orientée objet.

Gestion des erreurs en Java : Pour garantir que toutes les erreurs sont traitées, vous pouvez utiliser des blocs try, catch, et finally dans le code. Le bloc try contient le code qui pourrait générer une exception, et les blocs catch spécifient comment traiter chaque type d'exception. Le bloc finally contient le code qui doit être exécuté, que l'exception soit levée ou non. Une autre approche est d'utiliser des clauses throws dans la signature de la méthode pour déclarer que la méthode peut générer certaines exceptions, mais la responsabilité de les traiter est déléguée à l'appelant.

Ordre des blocs catch pour plusieurs types d'exceptions : Les blocs catch doivent être placés du plus spécifique au plus général. Cela signifie que les blocs pour les exceptions spécifiques doivent être énumérés avant les blocs pour les exceptions plus générales. Si les blocs sont placés dans l'ordre inverse, le compilateur générera une erreur, car un bloc catch plus général attraperait également les exceptions plus spécifiques, rendant les blocs suivants inatteignables.

Java 1

Différence entre throw et throws :

throw : Utilisé pour lever une exception explicite dans le code. Il est suivi d'une instance d'exception à lancer.

Exemple :

throw new IllegalArgumentException("mauvais argument ...");

throws : Utilisé dans la signature de la méthode pour indiquer que la méthode peut potentiellement générer une exception particulière. Il délègue la responsabilité de la gestion de l'exception à l'appelant de la méthode.

Exemple :

public void genius() throws IOException { // la methode genius peut est susceptible de lancer une IOException }

En résumé, throw est utilisé pour lever une exception spécifique, tandis que throws est utilisé pour déclarer les exceptions potentielles qu'une méthode peut générer.

EXERCICE 02 :

        
class ConcatIncorrecte {
    public static void main(String[] args) {
        String s = "China Blue";
        System.out.println(s);
        // version incorrecte
        // concatener(s, " Express");

        // version correcte:
        s = concatener(s, " Express");
        System.out.println(s);
    }

    /*
    Les raisons du comportement incorrect sont que :
    1. Les opérations sur les chaînes sont non destructives
       (elles créent une autre chaîne au lieu d'agir sur la chaîne originale).
    2. L'objet 's' est une référence, mais les références sont passées
       par valeur (on peut altérer l'objet référencé, mais pas la référence
       elle-même).

       Version incorrecte :
    public static void concatener(String s, String s2) {
        s += s2;
    }
    */

    // Version corrigée :
    public static String concatener(String s, String s2) {
        s += s2;
        return s;
    }
}
        
    

PROBLEME :

        
class Collection {

    // Cette variable stocke l'année actuelle. Vous verrez plus tard comment
    // utiliser la classe Data fournie par Java pour obtenir cette information
    // dynamiquement.

    private final static int CURRENT_YEAR = 2024;

    public static void main(String[] args) {
        Ustensile[] us = new Ustensile[5];
        us[0] = new AssietteRonde(1926, 8.4);
        us[1] = new Cuillere(1881, 7.3);
        us[2] = new AssietteCarree(1935, 5.6);
        us[3] = new Cuillere(1917, 8.8);
        us[4] = new AssietteRonde(1837, 5.4);

        afficherCuilleres(us);
        afficherSurfaceAssiettes(us);
        afficherValeurTotale(us);
    }

    static void afficherCuilleres(Ustensile[] us) {
        int nbCuilleres = 0;
        for (int i = 0; i < us.length; i++) {
            if (us[i] instanceof Cuillere) {
                nbCuilleres++;
            }
        }
        System.out.println("Il y a " + nbCuilleres + " cuillères.");
    }

    static void afficherSurfaceAssiettes(Ustensile[] us) {
        double somme = 0;
        for (int i = 0; i < us.length; i++) {
            if (us[i] instanceof Assiette) {
                somme = somme + ((Assiette) us[i]).calculerSurface();
            }
        }
        System.out.println("Surface totale des assiettes : " + somme);
    }

    static void afficherValeurTotale(Ustensile[] us) {
        double somme = 0;
        for (int i = 0; i < us.length; i++) {
            somme = somme + us[i].calculerValeur(CURRENT_YEAR);
        }
        System.out.println("Valeur totale de la collection : " + somme);
    }
}


abstract class Ustensile {
    private int annee;

    public Ustensile(int annee) {
        this.annee = annee;
    }

    public double calculerValeur(int anneeActuelle) {
        int age = (anneeActuelle - getAnnee());
        double valeur = 0;
        if (age > 50) {
            valeur = age - 50;
        }
        return valeur;
    }

    public int getAnnee() {
        return annee;
    }
}

abstract class Assiette extends Ustensile {
    public Assiette(int annee) {
        super(annee);
    }

    public abstract double calculerSurface();
}

class AssietteRonde extends Assiette {
    private double rayon;

    public AssietteRonde(int annee, double rayon) {
        super(annee);
        this.rayon = rayon;
    }

    public double calculerSurface() {
        return (3.14 * getRayon() * getRayon());
    }

    public double getRayon() {
        return rayon;
    }
}

class AssietteCarree extends Assiette {
    private double cote;

    public AssietteCarree(int annee, double cote) {
        super(annee);
        this.cote = cote;
    }

    public double calculerSurface() {
        return (getCote() * getCote());
    }

    public double calculerValeur(int anneeActuelle) {
        double valeur = 5 * super.calculerValeur(anneeActuelle);
        return valeur;
    }

    public double getCote() {
        return cote;
    }
}

class Cuillere extends Ustensile {
    private double longueur;

    public Cuillere(int annee, double longueur) {
        super(annee);
        this.longueur = longueur;
    }

    public double getLongueur() {
        return longueur;
    }
}
        
    
Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam