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.
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;
}
}
Ajouter un commentaire