Discussion :

[Linquisiteur]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Circle{
  double radius;
 
  public boolean equals(Circle c){
    return radius == c.radius;
  }
}

b:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[joel.drigo]

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...

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();

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".

x = new A();

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

y = x;

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

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.

[joel.drigo]

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;

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.

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.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

Grande z = (Grande) y;

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.

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
  }
}

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.

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Linquisiteur]

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.

[thelvin]

À 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.)

[thelvin]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 schema :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Linquisiteur]

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.

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[joel.drigo]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Linquisiteur]

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

[Linquisiteur]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Cercle extends FigureGeom
-rayon:double
+getPerimetre:double
+getAire():double
+toString() : String
+compare(Cercle c):boolean

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

class Test{

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[thelvin]

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)

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.

[Linquisiteur]

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

?

[thelvin]

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 ?

[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?

Sinon:
Fruit fruit = new Apple
serait tout aussi efficace

[thelvin]

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é ?

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.

[Linquisiteur]

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() ;

[thelvin]

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.