Compréhension des Object

Bonjour,

Je suis en 1ère informatique où j'y apprends de nombreux languages. Les examens approchent et je n'ai toujours rien compris aux Object en Java.

Je sais ce qu'est le polymorphisme, l'héritage une variable d'instance...
J'ai essayé avec toute la théorie que ma prof nous a donnés de faire des exercices que j'ai récupérés mais rien à faire, je bloque sur un bon nombre d'entre eux.
Je vais les poster ici et donner ma réponse.
___________________________________________________________
1)Combien d'instances de la classe A sont créées en exécutant le code suivant:

Code:

---

1 2 3 4 5 6 7

A x; A y ; A z; x = new A(); y = x; z = new A();

---

Ma réponse:
seulement 2 classes d'instance sont créées car seulement x et z ont été déclarées par la super classe A. (x = new A(); et z = new A();

2)Exercice 2: casting conversion explicite
Soit une classe Grande et une classe Petite telles que Grande extends Petite. Quelles sont les lignes correctes pour le compilateur et pour l'interpréteur?

1. Petite y = new Petite(); Grande x = (Grande) y; Petite z = x;
2. Grande x = new grande(); Petite y = x; Grande z = (Grande) y;
3. Grande x = new grande(); Petite y = x; Grande z = y;

1ère ligne est juste car pour crée un nouvel object, on doit le créer à partir de la super classe. grande hérite de petite.

3)Comment se comportent des deux programmes: qu'affiche le programme dans le(s) cas où aucune erreur ne se produit.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public class A { public A() { System.out.println(" Hello"); } }   public class B extends A {   public static void main(String[] toto){ B b = new B(); } }

---

Aucune idée..

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class A { public A(int x) { System.out.println("Hello"); } }   public class B extends A { public B(){ }   public static void main(String[] toto) { B b = new B(); } }

---

Idem j'ai cherché sans trouver.. A priori ça ne fait rien...

4) Supposons que Fruit, Apple, Orange, Golden Delicious Apple and Macintosh Apple sont déclarées comme ci-dessous. Supposons que fruit est une instance de GoldenDelicious et orange est une instance de Orange.

Fruit

Apple Orange

GoldenDelicious Macintosh

1. Est-ce que fruit est une instance de type Orange?
non car orange hérite de fruit et orange est l'instance de fruit

2. Est-ce que fruit est une instance de type Apple?
non car apple hérite de fruit et apple est l'instance de fruit

3. Est-ce que orange est une instance de type Fruit?
Oui car il hérite des propriété de l’objet fruit

4. Est-ce que orange est une instance de type Apple?
non car orange et fruit hérite tout deux de l’objet fruit mais ne sont pas lier directement. Il s'agit de classe enfant

5. Suppose que la méthode makeApple est définie dans la classe Apple. Est-ce que fruit peut utiliser cette méthode; est-ce que orange peut utiliser cette méthode?
fruit peut l'utiliser que dans un seul cas: fruit f = new apple(); Par contre orange ne pourra jamais utiliser makeApple car makeApple est une méthode propre a Apple

6. Suppose que la méthode makeOrangeJuice est définie dans la classe Orange. Est-ce que fruit peut utiliser cette méthode; est-ce que orange peut utiliser cette méthode?
fruit peut utiliser cette méthode que si fruit f = new orange();
autrement orange peut utiliser les méthodes qui lui sont propre

5)Qu'est-ce qui est faux dans ce code?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class test {   public static void main(String[] args){ Object fruit = new Fruit(); Object apple = (Apple) fruit; } }   public class Apple extends Fruit{   }   public class Fruit{   }

---

réponse: public class Apple extends Fruit. Si Apple est une sous classe de Fruit on n'a pas besoin d'un extends car Apple hérite directement de Fruit

6) overriding versus overloading

Code:

---

1 2 3 4 5 6 7

public class Test{ public static void main(String[] args){ Object circle1 = new Circle(); Object circle2 = new Circle(); System.out.println(circle1.equals(circle2)); } }

---

a:

Code:

---

1 2 3 4 5 6 7

public class Circle{ double radius;   public boolean equals(Circle c){ return radius == c.radius; } }

---

b:

Code:

---

1 2 3 4 5 6 7 8

public class Circle{ double radius;   public boolean equals(Object c){ return radius == ((Circle)c).radius; } }

---

Donner le résultat de la classe Test en utilisant la classe Circle (a) et puis la classe Circle (b); justifiez

Réponse:
a:
b: Je ne comprend pas..

7) Qu'affiche la méthode principale de la classe Test.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class A { int i = 1; static int j = 3;   void m() { i = 5; }   static void m1(){ j = 7; } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Test { public static void main(String[] args){ A a = new A();   System.out.println(a.i); System.out.println(A.j);   a.m(); A.m1();   System.out.println(a.i); System.out.println(A.j); } }

---

Réponse: j'affiche dans l'ordre
1
3
5
7
Je ne vois pas la différence des a et A

J'ai encore d'autre exercices mais si vous savez m'expliquez ceux-ci je saurai peut-être les faire par moi-même. L'examen de Java et Java programmation Object sont dans 1 et 2 semaines. Disons que parmi tous les langages c'est celui où je suis le plus mauvais.

Merci d'avance pour votre aide.

Salut,

je vais reprendre les questions une à une, suivant le temps que j'ai, vu qu'il y en a pas mal. Je verrai plus tard si j'ai le temps de répondre à la suite, à moins que quelqu'un d'autre intervienne avant...

Citation:

---

1)Combien d'instances de la classe A sont créées en exécutant le code suivant:
A x;
A y ;
A z;
x = new A();
y = x;
z = new A();

---

Citation:

---

Envoyé par Linquisiteur

Ma réponse:
seulement 2 classe d'instance sont crée car seulement x et z ont été déclarer par la super classe A. (x = new A(); et z = new A();

---

Bon point pour commencer : ta réponse est correcte dans le fond, mais inexacte dans la forme.

Déclarer une variable, c'est indiquer son type (sa classe en l'occurence) et son nom. Il y'a trois variables, déclarées.

A est une classe, un type de données constituées d'attributs et de méthodes.

Les trois variables ont pour classe A.

= est le signe d'affectation. new est un mot clé qui permet de créer une instance de classe (et non pas une classe d'instance). On dit aussi "instancier".

Citation:

---

x = new A();

---

ce code créé donc une instance de classe A est affecte la référence de cette instance à la variable x.

Citation:

---

y = x;

---

ce code affecte la référence de x à y. on ne créé pas de nouvelle instance.

Citation:

---

z = new A();

---

là on créé une nouvelle instance de classe A que l'on affecte à la variable z.

Il y'a donc bien création de 2 instances distinctes de la classe A.

Citation:

---

2)Exercice 2: casting conversion explicite
Soit une classe Grande et une classe Petite telles que Grande extends Petite. Quelles sont les lignes correctes pour le compilateur et pour l'interpréteur?

1. Petite y = new Petite(); Grande x = (Grande) y; Petite z = x;
2. Grande x = new grande(); Petite y = x; Grande z = (Grande) y;
3. Grande x = new grande(); Petite y = x; Grande z = y;

---

Citation:

---

Envoyé par Linquisiteur

1er ligne est just car pour crée un nouvel object on doit le crée à partir de la super classe. grande hérite de petite.

---

Pas du tout.

Grande étend Petite, donc Grande spécialise Petite et Petite généralise Grande. Ce sera plus facile à comprendre si on met Légume à la place de Petite et Carotte à la place de Grande : Une carotte est un légume alors que tous les légumes ne sont pas de carottes : il y a aussi des navets, des poivrons etc.

Prend un exemple de java pour mieux comprendre encore : les classes Integer et Double étendent la classe Number. Les nombres entiers sont tous des nombres. Tous les nombres ne sont pas de entiers, il y a aussi des nombres "réels" (les doubles précisions en réalité, mais pour simplifier, faisons cette analogie mathématique"),

Donc ce qui est Grande est aussi Petite, mais ce qui est Petite ne peut pas être Grande.

Caster c'est en gros donner un nom plus général.
Si on créé une instance de Grande, on peut dire qu'elle est Petite pour certain traitement.

Citation:

---

1. Petite y = new Petite(); Grande x = (Grande) y; Petite z = x;

---

y est de type Petite et est instanciée en Petite. Donc n ne peut pas caster y en Grande, ce serait dire que tout ce qui est Petite peut être Grande, soit dire que tous les légumes sont des carottes.

Citation:

---

2. Grande x = new grande(); Petite y = x; Grande z = (Grande) y;

---

x est de classe Grande et instanciée comme telle. y est du type Petite et peut donc référencer une variable de classe plus spécialisée.

On est même pas obliger de caster. Par exemple, en java :

Code:

---

List<String> list = new ArrayList<String>();

---

y référence donc une variable d'instance Grande. On peut donc la caster en Grande. Donc on peut écrire

Code:

---

Grande z = (Grande) y;

---

Citation:

---

3. Grande x = new grande(); Petite y = x; Grande z = y;

---

ici c'est quasiment la meme chose que la 2, sauf qu'on ne caste pas y quand on affecte z. Or, je vais l'exprimer maladroitement, mais c'est pour être plus clair (je l'espère), si l'exécution "sait quelle super classe une instance peut être, elle ne peut pas savoir quelle sous classe elle est tout seule, sans caster explicitement".

y référence bien une instance de Grande, mais est du type Petite. il faut donc caster y en Grande pour pouvoir l'affecter à z.

C'est donc la proposition 2. qui compile.

3)Comment se comportent des deux programmes: qu'affiche le programme dans le(s) cas où aucune erreur ne se produit.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

public class A { public A() { System.out.println(" Hello"); } }   public class B extends A {   public static void main(String[] toto){ B b = new B(); } }

---

Citation:

---

Envoyé par Linquisiteur

Aucune idée..

---

Hum, je voudrais pas t'inquiéter outre mesure, mais c'est quand cet exam ? parce que si tu n'as aucune idée de ce qu'il se passe lors de l'éxecution de de programme (enfin on suppose qu'on exécute la classe B)., tu as du boulot avant d'être à l'aise à ton exam:?

On écrit Hello dans la console lors de l'éxécution de l'unique constructeur de A.

B étend A, donc son constructeur unique va appelé le constructeur unique de classe A (implicitement).

Donc créer une instance de classe B, exécutera le constructeur de la classe A, et donc écrira dans la console Hello.

Ce que fait ce programme.

Citation:

---

3)Comment se comportent des deux programmes: qu'affiche le programme dans le(s) cas où aucune erreur ne se produit.

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class A { public A(int x) { System.out.println("Hello"); } }   public class B extends A { public B(){ }   public static void main(String[] toto) { B b = new B(); } }

---

La on a quasiment la même chose que dans le code précédent. La différence c'est que le constructeur de la classe A a un argument de type int.

Quand on indique pas de constructeur, on a un constructeur implicite sans argument, mais dès qu'un constructeur est indiqué, le constructeur sans argument n'est plus invocable, y compris quand on étend la classe.

La classe B peut déclarer un constructeur sans argument, mais doit absolument appeler le constructeur de A avec un argument de type entier, de cette manière :

Code:

---

1 2 3 4 5 6 7 8 9

public class B extends A { public B(){ super(42); }   public static void main(String[] toto) { B b = new B(); } }[

---

le code proposé ne compile pas donc, parce qu'il n'y a pas cet invocation du constructeur de la super classe.

Merci beaucoup :) Je suis en train de faire une page de réponse pour faire partager à ma classe. Oui je suis mauvais en ce qui concerne les objet en java l'an dernier il y a eu 80% d’échec en 1er session..
Ces un de mes dernier examen mais je préfère m'y prendre à l'avance ..

Mon blocus a été composer de 95% de devoir. Donc très peu de temps pour revoir certain cours. :cry:

À la question 1) : compter les instances, c'est juste compter les new.
Le mot-clé new sert à créer une nouvelle instance d'objet, c'est donc pas plus compliqué que ça.
(Bon, ça ne marche que quand on n'utilise pas d'autre mécanisme pour créer des objets, ce qui est le cas ici.)

4) L'énoncé est mal fait. Ça devrait être :

Supposons que Fruit, Apple, Orange, GoldenDelicious et Macintosh sont déclarées comme ci-dessous.

Code:

---

1 2 3 4 5 6 7

class Fruit   class Apple extends Fruit class Orange extends Fruit   class GoldenDelicious extends Apple class Macintosh extends Apple

---

Code:

---

1 2 3 4 5 6 7 8 9

Fruit | \ | \ Apple Orange | \ | \ | Macintosh | GoldenDelicious

---

Supposons que fruit est une instance de GoldenDelicious et orange est une instance de Orange.

Code:

---

1 2	GoldenDelicious fruit = new GoldentDelicious(); Orange orange = new Orange();

---

Refais la question comme ça.

5) Cette question est indépendante de la question 4). Il n'y a rien de déjà défini. Refais-la.

Encore merci je ne m'attendais pas à autant d'aide :)

La question 5 est posée tel quel dans la feuille d'exercice que j'ai trouver.
J'ai mon 1er examen vendredi et je dois remettre mon cour de math en ordre plus commencer a bloquer pour économie. Donc désoler de ne pas être très présent sur mon propres topic je m'attendais a des réponses plus lentes. En tout cas l'air de rien j'ai bien lus et relues vos explication et je commence à comprendre doucement mais surement. Mon cour sur les object n'est clairement pas assez basée sur des exercice mais sur de la théorie hors l'examen contient peu de théorie.. Grâce a cela j'augmente déjà pas mal mais chance de réussite en 1er sessions.

Si vous avez envie j'ai d'autre exercice qui porte sur d'autre matière comme l'overiding,.. je comprend le principe mais entre la théorie et la pratique.. On n'en a pas fait en progra.

Citation:

---

6) overriding versus overloading

---

exercice sur la différence entre overriding et overloading : je trouve pas super l'exemple donné, parce qu'il concerne la méthode equals(Object) qui a un contrat bien particulier, qui en l'occurence n'est pas respecté (il faudrait surcharger hashCode()),

en plus la mise en évidence de la différence doit être effectué sur une autre problématique, le typage des références.

mais bon on va faire avec.

l'overriding c'est le fait dans une classe étendant une autre de redéfinir une méthode de cette dernière.

Ici la classe Circle de l'exemple b :

Code:

---

1 2 3 4 5 6 7 8 9

public class Circle{ double radius;   public boolean equals(Object c){ return radius == ((Circle)c).radius; } }

---

redéfinit la méthode equals(Object) de la classe Object (dont la classe Circle hérite implicitement).

Lorsqu'on appelle la méthode equals(Object) sur une instance de cette classe, et de toutes ses sous classes qui ne redéfinirait pas cette méthode, on exécute le code qu'il y a dans cette classe et pas celui de la méthode equals(Object) de la classe Object.

L'overloading c'est écrire des méthodes dans une classe ou une sous classe qui ont le même nom d'une méthode existante, mais pas les mêmes arguments (pas le même nombre ou pas le même type).

c'est ce qui est fait dans le cas a)

Code:

---

1 2 3 4 5 6 7 8

public class Circle{ double radius;   public boolean equals(Circle c){ return radius == c.radius; } }

---

ici on ne surcharge pas la méthode equals(Object) on créé une nouvelle méthode qui a le même nom, mais un argument de type Circle et pas Object

Maintenant, que se passe t il lorsqu'on exécute le code

Code:

---

1 2 3 4 5 6 7

public class Test{ public static void main(String[] args){ Object circle1 = new Circle(); Object circle2 = new Circle(); System.out.println(circle1.equals(circle2)); } }

---

Ici on instancie 2 instance de classe Circle, mais stocke leur référence dans des variables typées Object. On ne modifie pas le rayon dans les deux cas, donc le rayon est la valeur par défaut d'un double, donc 0 (0d pour les puristes).

Lorsqu'on invoque la méthode equals telle qu'elle est écrite dans le cas b), donc de l'overriding, on appelle une méthode qui attend un argument de type Object, donc cette méthode est bien appelée, puis on caste en Circle pour récupérer le rayon et le comparer.

les deux rayons sont à 0, donc égaux, donc la condition est vérifiée, donc on retourne true.

Dans le cas a) par contre, on invoque une méthode equals avec un argument de type Object, alors qu'il y a 2 méthodes equals, l'une avec un argument de type Circle, l'autre avec un argument de type Object. C'est bien sur l'argument de type conforme à celui de la variable, donc Object, qui sera exécutée (et non pas celle correspondant au type de l'instance dont la référence est dans la variable).

Donc on appelle la méthode equals(Object) de la classe Object (dont hérite impliciment Circle) et cette méthode ne renvoit true que si la référence de l'argument est la même que celle de this : comme on a bien deux instances différentes de la classe Circle, leur référence ne sont pas égales, donc l'appel renvoit false.


Pour donner un exemple plus clair (je l'espère en tout cas), voici un petit exemple, sans subtilité de typage de la variable passée en argument :

je défini une classe qui a une méthode qui permet d'obtenir une valeur de type String, soit en uppercase, soit telle quelle.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Exemple1 {   private String name;   public Exemple1(String name) { this.name=name; }   public String getName(boolean upper) { if ( upper && name!=null ) { return name.toUpperCase(); } return name; }   }

---

Maintenant je veux faire une nouvelle classe qui a les mêmes caractérisques, plus d'autres éventuellement, mais je sais que pour cette classe là, je vais avoir souvent besoin du nom en uppercase : je vais me créé donc ce qu'on appelle une méthode de convénience, qui évitera qu'on ait à passer systématiquement un booléen en argument :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class Exemple2 extends Exemple1 {   public Exemple2(String name) { super(name); }   public String getName() { return super.getName(true); }   }

---

ici je suis dans le cas de l'overloading : j'ai crée une méthode (ma méthode de convénience) qui avait le même nom qu'une méthode existante dans ma classe, ou dans une de ses classes parents, et j'ai changé le nombres des arguments.

maintenant je veux faire une classe qui a les caractéristiques de Exemple1, mais tel que le nom est la combinaison du nom et d'un entier

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class Exemple3 extends Exemple1 {   private int indice;   public Exemple3(String name, int indice) { super(name); this.indice=indice; }   public int getIndice() { return indice; }   public String getName(boolean upper) { String name = super.getName(upper): if ( name==null ) return null; // on décide que si le nom est null, on ignore l'indice return name+indice; }   }

---

ici on est dans le cas de l'overriding : on a simplement rédéfinit notre méthode de la superclasse pour quelle fasse autre chose. bon ici elle fait presque pareil puisqu'elle ajoute juste un indice numérique

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class Exemple4 extends Exemple3 {   public Exemple4(int indice) { super(null, indice); }   public String getName(boolean upper) { return String.valueOf(getIndice()); }   }

---

et là on a redéfini la méthode pour qu'elle ignore complètement le nom : d'ailleurs on la supprimé des arguments du constructeur. Cette classe renvoit un nom qui n'est constitué que du nombre. on est toujours ici dans le cas de l'overriding.

pour la question 7, ta réponse est la bonne.

Citation:

---

Envoyé par Linquisiteur

Je ne vois pas la différence des a et A

---

Dans ce petit programme on définit une classe A puis on déclare une variable a e classe A que l'on instancie :

Code:

---

A a = new A();

---

cette classe A a une variable d'instance i et une variable statique j.

chaque instance de A a une variable i de valeur différente :

Code:

---

1 2 3 4 5 6

A a1 = new A(); A a2 = new A(); a1.i=10; a2.i=100; System.out.println(a1.i); System.out.println(a2.i);

---

va afficher :

10
100

par contre la variable j est la même pour toutes les instances de A

Code:

---

1 2 3 4 5 6

A a1 = new A(); A a2 = new A(); a1.j=10; a2.j=100; System.out.println(a1.j); System.out.println(a2.j);

---

va afficher :

100
100

Il est d'usage pour acceder à une variable statique d'une instance de classe d'y acceder par la classe et non l'instance, justement parce que la variable est là même pour toutes les instances,

donc l'extrait de code suivant devrait être écrit comme suit pour être conformer aux conventions d'usage :

Code:

---

1 2 3 4 5 6

A a1 = new A(); A a2 = new A(); A.j=10; A.j=100; System.out.println(a1.j); System.out.println(a2.j);

---

qui affichera bien sûr :

100
100

mais avec cette notation on comprend tout de suite qu'on modifier la valeur de j pour toutes les instances de A, alors que dans le cas précédent, c'est moins évident. si on a pas le source de la classe A en plus, on ne peut pas savoir que j est statique : c'est donc encore plus utile d'utiliser la bonne notation.

voilà pour la différence entre a et A dans ce code.

merci, je tenterai de faire les autre exo par moi même et si sa ne vous ennui pas vous les montrés ^^'

De retour :)

Je me posais la question pour la question 5 est ce que ma réponse était juste?

Sinon j'ai continuer ma série d'exercice:

Exercice8)
La classe Tortue a pour super-classe directe Animal qui a lui-même Lievre pour sous-classe directe. TortueDesGalapagos et TortueDeFloride sont deux sous-classes indirectes de Animal qui ont pour super-classe directe Tortue.

Dessinez le diagramme de classes représentant la hiérarchie des classes décrite ci-dessus.
Déterminez, dans la classe dont un extrait est donné ci-dessous, si l'appel à compareVitesse figurant dans la deuxième instruction du corps de la méthode main:
• n'est pas ambigu, justifiez
• est ambigu, justifiez

public static void main(String[] args){
Tortue t = new TortueDeFloride() ;
int i = compareVitesse(t,t);
}

public static int compareVitesse(Animal a, Animal b) { …}
public static int compareVitesse(Animal a, Tortue b) { …}
public static int compareVitesse(Tortue a, Animal b) { …}
public static int compareVitesse(Lievre a, Animal b) { …}
public static int compareVitesse(Animal a, TortueDeFloride b) { …}


Réponse:

Dessin du diagramme des classes:

Animal
/ \
Tortue Lièvre
/ \
TortueDeFloride| TortueDesgalapagos

pour la 2eme question j'ai du mal à comprendre ce qui est demander

Ce code:
public static void main(String[] args){
Tortue t = new TortueDeFloride() ;
int i = compareVitesse(t,t);
}
me laisse comprendre que la réponse n'est pas ambigu car ont crée une instance de type TortueDeFloride et on compare sa vitesse avec elle même.
La réponse sera que la vitesse est égale.
Mais j'ai surement pas comprit la question d'où la suite de la question dont je ne vois pas le rapport...








Exercice 9: overriding
Soit la hiérarchie de classes suivantes: ClasseA est la classe de base, ClasseB hérite de ClasseA, ClasseC hérite de ClasseB. Etudier ce programme afin de mettre en évidence la façon dont s'effectuent les conversions par transtypage.

Code:

---

1 2 3 4 5 6 7 8 9 10

class ClasseA { protected int x1, x2;   public ClasseA(int a, int b) {x1 = a ; x2 = b ;}   public void affiche() {System.out.println(x1+" "+x2) ;} }

---

//----------

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class ClasseB extends ClasseA { protected int y;   public ClasseB(int a, int b, int c) { super(a,b) ; y = c ; } public void affiche() {System.out.println(x1+" "+x2+" "+y) ;} }

---

//----------

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class ClasseC extends ClasseB { private int z;   public ClasseC(int a, int b, int c, int d) { super(a,b,c); z = d ; }   public void affiche() {System.out.println(x1+" "+x2+" "+y+" "+z) ;} }

---

//----------

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class Ex { public static void main(String args[]) { ClasseA a = new ClasseA(2,2); ClasseB b = new ClasseB(4,5,6); ClasseC c = new ClasseC(70,70,70,70); a = b; a.affiche(); a = c; a.affiche(); b = c; b.affiche();   ClasseB b2 = new ClasseB(80,80,80); b2.affiche(); ClasseB b3 = new ClasseC(9,9,9,9); b3.affiche(); ClasseA a2 = (ClasseC)b3; a2.affiche(); ClasseA a3 = (ClasseC)b2; a3.affiche(); } }

---

Réponse:

l'output sera
4,5
70,70
70,70,70

80,80,80
9,9,9
9,9,9,9
80,80,80,80

Si je comprend bien le fait de faire:
ClasseA a3 = (ClasseC)b2; est un transtypage donc en gros je modifie a3 qui est dans classeA en la mettant dans la classeC?



Exercice 10: overloading

Observer le diagramme de classes ci-dessous: quelles sont les méthodes surchargées (overloading) et les méthodes écrasées (overriding).
Observer la méthode principale de la classe Test, expliquer les problèmes rencontrés par le compilateur, et pour les instructions non erronées, détailler le choix des méthodes effectué par le compilateur.

Code:

---

1 2 3 4 5 6 7 8 9 10

FigureGeom -couleur:String -rempli:voolean -date: Date +setCouleur(String c): void +rempli(): void +getCouleur():String +toString() +compare(FigureGeom f):boolean

---

Code:

---

1 2 3 4 5 6 7

Cercle extends FigureGeom -rayon:double +getPerimetre:double +getAire():double +toString() : String +compare(Cercle c):boolean

---

Code:

---

1 2 3 4 5 6 7 8

Parallelogramme extends FigureGeom -hauteur :double -largeur:double -angle:double +getPerimetre:double +getAire():double +toString() : String +compare(Parallelogramme p):boolean

---

Code:

---

1 2 3

Rectangle extend Parallelogramme +toString() : String +compare(Rectangle r):boolean

---

Code:

---

1 2 3

Carre extend Rectangle +toString() : String +compare(Carre c):boolean

---

class Test{

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public static void main(String[] toto){   Cercle x = new Cercle(3); Figure y = new Rectangle(3,4,50); boolean b1 = y.compare(x); boolean b2 = x.compare(y); deplacer(x,5); deplacer(y,5.3); deplacer(y, 5); deplacer((Parallelogramme)y, 5); deplacer((Parallelogramme)x, 5); }   public static void deplacer(Cercle x, int y) {…} //def1 public static void deplacer(Figure x, int y) {…} //def2 public static void deplacer(Rectangle x, double y){ …} //def3 public static void deplacer(Parallelogramme x, long y){…} //def 4   }

---

Cercle x = new cercle(3) Sa va être accepter

Figure y = new Rectangle(3,4,50); Je suppose qu'il s'agit de figureGeom.
on va utiliser le constructeur de Parallélogramme. Sa sera accepter

boolean b1 = y.compare(x); Sa va fonctionner mais on va utiliser la méthode compare dans FigureGeom

boolean b2 = x.compare(y); même chose que plus haut

deplacer(x,5); fonctionnera mais va utiliser: def1

deplacer(y,5.3); fonctionnera mais va utiliser def3

deplacer(y, 5); fonctionnera mais va utiliser def4

deplacer((Parallelogramme)y, 5); fonctionnera mais va utiliser def4

deplacer((Parallelogramme)x, 5); fonctionnera pas

Citation:

---

Envoyé par Linquisiteur

Je me posais la question pour la question 5 est ce que ma réponse était juste?

---

Tu l'as pas comprise la question 5). Tu as répondu en tenant compte de ce qui est dit dans la question 4). Il ne fallait pas, c'est une nouvelle question. Ce qui est défini dans la question 4) ne concerne pas la question 5).

8)

Citation:

---

Envoyé par Linquisiteur

pour la 2eme question j'ai du mal à comprendre ce qui est demander

---

La question c'est est-ce que ça compile et, que ce soit oui ou non, pourquoi ?

Cette question se pose, parce qu'il existe plusieurs méthodes de nom compareVitesse(), qui prennent toutes des paramètres différents.
Puisqu'il y en a plusieurs, le compilateur est-il capable de décider laquelle prendre ?

Rappel : pour décider si les paramètres d'une méthode correspondent au type d'une variable, le type concret de l'instance n'est pas important, car il concerne le runtime et non pas le compilateur. La méthode à appeler est choisie pendant la compilation, pas pendant le runtime.

Donc, il ne faut pas tenir compte de new TortueDeFloride(), ça n'intervient pas.
Il faut tenir compte de Tortue t, c'est ça qui compte.

Donc pour la question 5 ce qui est faux sera:

Object fruit = new Fruit();
Object apple = (Apple) fruit;

Je devrais avoir par exemple:

Fruit fruit = new Fruit
Apple apple = (Apple) fruit

Donc je crée un objet fruit et ensuite je le caste en type Apple

?

Ben... Vu que c'est faux, ça va pas être facile de dire ce qu'il fallait mettre à la place. En tout cas, ce que tu proposes fait exactement la même faute.
C'est bien ça qui est faux, mais pourquoi ?

Fruit fruit = new Fruit
Apple fruit = (Apple) fruit

Je n'est pas crée d'instance apple avant mais si je réutilise fruit sa fonctionnera?

Sinon:
Fruit fruit = new Apple
serait tout aussi efficace

Citation:

---

Envoyé par Linquisiteur

Fruit fruit = new Fruit
Apple fruit = (Apple) fruit

Je n'est pas crée d'instance apple avant mais si je réutilise fruit sa fonctionnera?

---

Le plus simple serait d'essayer -_-°.
Enfin bref, on ne peut pas caster une instance d'une classe vers un de ses sous-types. Ce qui est normal d'ailleurs, ça ne voudrait rien dire. Comment et quand le constructeur de la sous-classe serait-il appelé ?

Citation:

---

Envoyé par Linquisiteur

Fruit fruit = new Apple
serait tout aussi efficace

---

Ce serait bien plus efficace. L'objet étant bien de type concret Apple, il peut être casté en Apple.

Merci je note ^^

J'essaie de comprendre pour la question 8 mais j'ai une question

Qu'elle est la différence entre Tortue t = new TortueDeFloride() ;
et Animal t = new TortueDeFloride() ;

Le type déclaré de la variable t, autrement dit le type que le compilateur connaît pour la variable t, n'est pas le même.

Comme c'est le compilateur qui choisit quelle est la méthode appelée, c'est important.

j'ai du mal à comprendre. Dans les 2 cas je crée une tortue des galapagos?
Donc ma tortueDesGalapagos héritera de toute les caractéristique de animal et tortue. Enfin bref je suis assez perdu

Oui, mais dans un cas tu mets cette tortue dans une variable de type Animal. Donc ça veut dire que le programme qui utilise cette variable, marche avec n'importe quel Animal : n'importe quelle tortue, mais aussi un Lièvre.

Dans l'autre cas tu le mets dans une variable de type Tortue. Donc ça veut dire que le programme ne marcherait pas avec un Lièvre, mais il marche avec n'importe quelle Tortue, de floride, des galapagos ou d'ailleurs.

L'objet que tu as mis dans cette variable, il se trouve qu'en réalité c'est une TortueDeFloride. Mais c'est pas important. Le type de la variable dit que ça marche avec n'importe quel Tortue, tu aurais pu y mettre une autre Tortue si tu voulais.
Et dans le deuxième cas, la variable étant de type Animal, ça marcherait même avec n'importe quel Animal.

Allez une dernière question à propos de la question 8 car je suis simple d'esprit :roll:

Comment puis
public static void main(String[] args){
Tortue t = new TortueDeFloride() ;
int i = compareVitesse(t,t);
}

public static int compareVitesse(Animal a, Animal b) { …} fonctionne
public static int compareVitesse(Animal a, Tortue b) { …} fonctionne
public static int compareVitesse(Tortue a, Animal b) { …} fonctionne
public static int compareVitesse(Lievre a, Animal b) { …} fonctionne pas
public static int compareVitesse(Animal a, TortueDeFloride b) { …} fonctionne pas

Pour la dernière vu que le type est tortue le compilateur n’acceptera pas même si en pratique le programme pourrait tourner dans ce cas. J'ai raison?


En tout cas je tiens à vous remerciez pour toute vos réponse en espérant ne pas trop vous embêtez.. Je fais passer les explications à toute ma classe sa sauvera surement quelque personne :oops:
L'an dernier cette examen à eu un tôt d’échec de 80% en 1er session :aie:

Citation:

---

Envoyé par Linquisiteur

public static int compareVitesse(Animal a, Animal b) { …} fonctionne
public static int compareVitesse(Animal a, Tortue b) { …} fonctionne
public static int compareVitesse(Tortue a, Animal b) { …} fonctionne
public static int compareVitesse(Lievre a, Animal b) { …} fonctionne pas
public static int compareVitesse(Animal a, TortueDeFloride b) { …} fonctionne pas

---

On ne te demande pas si elles fonctionnent. On te dit qu'elles sont toutes là, le compilateur doit donc choisir laquelle il va appliquer. On te demande si le compilateur est capable de choisir la bonne méthode à appliquer, autrement dit, l'appel est-il ambigu, oui ou non ?

Citation:

---

Pour la dernière vu que le type est tortue le compilateur n’acceptera pas même si en pratique le programme pourrait tourner dans ce cas. J'ai raison?

---

En effet, elle ne s'applique pas aux paramètres indiqués (Tortue, Tortue.) Le compilateur ne la retient pas comme candidate applicable, il ne l'appellerait pas même si c'était la seule méthode de ce nom.
Mais il n'y a pas de "en pratique." Si la variable passée était de type TortueDeFloride, les paramètres (TortueDeFloride, TortueDeFloride) s'appliqueraient et elle serait une candidate. Ce n'est pas le cas, la variable est de type Tortue, pas TortueDeFloride. Fin de l'histoire.

Citation:

---

Envoyé par Linquisiteur

En tout cas je tiens à vous remerciez pour toute vos réponse en espérant ne pas trop vous embêtez.. Je fais passer les explications à toute ma classe sa sauvera surement quelque personne :oops:
L'an dernier cette examen à eu un tôt d’échec de 80% en 1er session :aie:

---

Il est clair que ces exercices te dépassent complètement. Tu ne réalises clairement pas la distance. Apparemment ça ne vient pas de toi mais du cours lui-même, s'il y a 80% d'échec.

"Faire passer" ça, ne sauvera personne qui n'aurait pas su y répondre facilement.

Il n'est jamais trop tard pour le réussir :)

public static int compareVitesse(Animal a, Animal b) { …}
public static int compareVitesse(Animal a, Tortue b) { …}
public static int compareVitesse(Tortue a, Animal b) { …}
public static int compareVitesse(Lievre a, Animal b) { …}
public static int compareVitesse(Animal a, TortueDeFloride b) { …}

Bon j'ai réfléchis, c'est ambigu entre la 2eme et la 3eme méthode.
Le compilateur va prendre ce qui est le plus proche des types donner mais ne pourras pas choisir entre la seconde et la troisième car elle se valent entre elle.

Sinon la 1er est possible mais la 4 et 5 ne sont pas possible

Exactement.

merci beaucoup. Je commence à sortir de l'eau grâce a vous :ccool:

De retour, bon 1er semaine d'examen passer. Mardi exam de java qui contiendra plus d'objet que prévu. j'ai relu toute vos réponse attentivement et j'ai eu plusieurs déclic sur plein de point :)

Mais j'ai encore des questions que je vais poster dans l'ordre après j'aurais presque comprit la matière sur cette partie :)

Il y a une chose qui ma interpeller

dans la question 1 pour créer une classe d'instance on fait
a = new A
tandis que dans la question 5 on a
Object fruit = new Fruit

Bon d'après mon idée le "Object" est le type de la variable (pour le compilateur) comme expliquer avec les tortues de la question 8 mais je me pose la question dans l'exercice 1 a est de type A ?
on voit A x;
x = new A();
donc si j'ai bien comprit on peut spécialiser avant de crée l'instance de classe.

Ensuite je reviens à l'exercice 4 car en relisant j'ai remarqué qu'il y avait un piège dans l’énoncer qui ma sûrement faussé mes réponses donc je le refais

1. Non car fruit est l'instance de GoldenDelicious qui hérite de Apple et dont Apple hérite de Fruit, donc Orange n'est pas une précision de GoldenDelicious
2.Oui car fruit est la précision de Apple
3.Oui mais seulement si Fruit orange = new Orange
4.Non car Apple est une sous classe fils au même niveau que Orange
5. fruit peut utiliser cette méthode seulement si fruit et déclaré de type Apple ou Fruit orange ne pourra pas l'utiliser sauf si orange est de type Fruit
6.fruit peut l'utiliser seulement si fruit est déclarer comme suit
(Fruit fruit = new GoldenDelicious)
pour orange il n'y aura aucun problème qu'il soit de type Fruit ou de type Orange

pour la suite j'ai réfléchie à la question 9 poster précédemment (c'est super tordu et malsain)

l'output sera:

2 2 6
2 2 6 70
4 5 6 70

80 80 80
9 9 9
9 9 9 9
80 80 80

Malheureusement j'ai oublier mon chargeur en classe donc je me retrouve juste avec mon petit lenovo sous linux ou je n'ai rien installer permettant de compiler du java --' pratique quand on as même pas le temps d'aller au toilette en paix... (j'ai étudier le shell en plein examen :ccool:)

Citation:

---

Envoyé par Linquisiteur

dans la question 1 pour créer une classe d'instance on fait

---

"Instance de classe," pas "classe d'instance."

Citation:

---

Envoyé par Linquisiteur

Bon d'après mon idée le "Object" est le type de la variable (pour le compilateur) comme expliquer avec les tortues de la question 8 mais je me pose la question dans l'exercice 1 a est de type A ?

---

La variable c'est x, pas a. Mais x est de type A, oui.

Citation:

---

Envoyé par Linquisiteur

on voit A x;
x = new A();
donc si j'ai bien comprit on peut spécialiser avant de crée l'instance de classe.

---

Spécia-quoi ?

C'est exactement la même chose que :

Code:

---

1 2	int i; i = 8;

---

Sauf qu'au lieu de int on a A, et que les int n'étant pas des objets, ce qu'on assigne à une variable int n'est pas des instances d'objets, donc pas besoin de new.

Citation:

---

Envoyé par Linquisiteur

1. Non car fruit est l'instance de GoldenDelicious qui hérite de Apple et dont Apple hérite de Fruit, donc Orange n'est pas une précision de GoldenDelicious

---

Dis juste que GoldenDelicious n'est pas une classe descendante d'Orange. (ou qu'Orange n'est pas un type ascendant de GoldenDelicious.)

Citation:

---

Envoyé par Linquisiteur

2.Oui car fruit est la précision de Apple

---

préci-quoi ? Ça veut rien dire.
Est-ce que la variable fruit contient une instance d'une classe qui est une classe descendante de Apple ? C'est la seule question qu'on te pose.

Citation:

---

Envoyé par Linquisiteur

3.Oui mais seulement si Fruit orange = new Orange

---

Et vu que l'énoncé n'indique pas la déclaration de la variable orange, mais indique que cette variable est assignée orange = new Orange();, oui tout court, sans condition.

Citation:

---

Envoyé par Linquisiteur

4.Non car Apple est une sous classe fils au même niveau que Orange

---

Mouais. Même niveau donc aucune est sous-type de l'autre, ok.

Citation:

---

Envoyé par Linquisiteur

5. fruit peut utiliser cette méthode seulement si fruit et déclaré de type Apple ou Fruit orange ne pourra pas l'utiliser sauf si orange est de type Fruit

---

Non. La méthode est ajoutée au type Apple, Fruit est ascendant de Apple, pas descendant, donc ne dispose pas de cette méthode. Donc tout ce qui est de type Fruit ne peut pas s'en servir.

Citation:

---

Envoyé par Linquisiteur

6.fruit peut l'utiliser seulement si fruit est déclarer comme suit
(Fruit fruit = new GoldenDelicious)
pour orange il n'y aura aucun problème qu'il soit de type Fruit ou de type Orange

---

Non, même raisonnement.

Citation:

---

Envoyé par Linquisiteur

pour la suite j'ai réfléchie à la question 9 poster précédemment (c'est super tordu et malsain)

l'output sera:

2 2 6
2 2 6 70
4 5 6 70

---

Complètement pas. Aucun objet n'a été créé avec les paramètres 2, 2, 6, alors pourquoi ça s'afficherait ?
L'exercice est difficile à suivre je suis d'accord. Mais de là à inventer des données venant de nulle part...

Code:

---

1 2 3 4 5 6 7 8 9 10 11

ClasseA a = new ClasseA(2,2); ClasseB b = new ClasseB(4,5,6); ClasseC c = new ClasseC(70,70,70,70); a = b; a.affiche(); a = c; a.affiche(); b = c; b.affiche();   ClasseB b2 = new ClasseB(80,80,80); b2.affiche(); ClasseB b3 = new ClasseC(9,9,9,9); b3.affiche(); ClasseA a2 = (ClasseC)b3; a2.affiche(); ClasseA a3 = (ClasseC)b2; a3.affiche();

---

Et bien mon raisonnement devait être fausser :(
je retente

a=b;afficher(); //on met b dans une classe a on va donc généraliser ce qui fait que on perdre la 3eme valeur: 2 2

a=c;a.afficher(); //idem: 2 2

b=c;b.afficher(); 70 70 70

Non, il y a application du polymorphisme.

La variable b a été assignée avec new ClasseB(). L'objet qu'elle contient est donc de type concret ClasseB.

Comme ClasseB est une sous-classe de ClasseA, on peut assigner une variable type ClasseB à une variable de type ClasseA. C'est tout le principe des classes et de l'héritage.

Mais cela ne change strictement rien à l'objet assigné. Il ne subit aucune modification, il reste toujours le même. Il garde les mêmes propriétés et le même comportement. C'est le même, juste le même.

Cet objet étant de classe concrète ClasseB, il se comportera comme un objet de classe ClasseB.
Et donc, a.affiche() appelle la méthode affiche() de ClasseB, ce qui est en fait la même chose que ce qu'aurait fait b.affiche().

Faut réviser le cours sur le polymorphisme et la redéfinition de méthode.

... Et tu n'arriveras à rien si tu n'essaies pas de vérifier toi-même ce que disent tes cours. Un langage de programmation ne s'apprend pas qu'avec un livre. Il faut se mettre devant l'ordinateur et essayer des trucs. Ce que tu fais ne sert à rien, tu ne comprendras jamais quoi que ce soit.