TD Java Héritage Et Polymorphisme

 

TD/TP Java Héritage et polymorphisme

Exercice 60 : définition défi nition d’une d’ une classe dérivée, dér ivée, dro droits its d’accès On dispose de la classe suivante : class Point { public void initialise (int x, int y) { this.x = x ; this.y = y ; } public void deplace (int dx, int dy) { x += dx ; y += dy ; } public int getX() { return x ; } public int getY() { return y ; } private int x, y ; } Réaliser une classe PointA, dérivée de Point disposant d’une méthode affiche affichant (en fenêtre console) les coordonnées d’un point. Ecrire un petit programme utilisant les deux classes Point et PointA. Que se passerait-il si la classe Point ne disposait pas des méthodes getX et getY ?

Exercice Exer cice 61 : descrip desc riptio tion n d’une classe class e dérivée dérivé e On dispose de la classe suivante :

class Point  {public void setPoint(intx,inty) {this.x=x;this.y=y; {this.x=x;this.y=y;} }   public void deplace (int dx, int dy) { x += dx ; y += dy ; }  public void affCoord ()   { System.out.println ("Coordonnees : " + x + " " + y) ;   }   private int x, y ;  } Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis par deux coordonnées (int ) et un nom (caractère). On y prévoira les méthodes suivantes : • setPointNom pour définir les coordonnées et le nom d’un objet de type PointNom, • setNom pour définir seulement le nom d’un tel objet,

• affCoordNom pour afficher afficher les coordonnées et le nom d’un obj objet et de type PointNom PointNom.. Écrire un petit  programme utilisant la classe classe PointNom.



Nous définissons une classe dérivée en utilisant le mot clé extends :

class PointNom extends Point  Dans cette classe contenir le nom duPointNom point : , nous introduisons un champ (de préférence privé) destiné à

 

 private char nom ; La méthode setNom est triviale. Compte tenu de l’encapsulation des données de Point , nos deux autres méthodes doivent absolument recourir aux méthodes publiques de Point .

Exercice Exer cice 62 : Héritage Hérita ge et appels de construc cons tructeur teur On dispose de la classe suivante (disposant cette fois d’un constructeur) :

class Point  {   publicPoint(intx,inty) {this.x=x;this.y=y;} {this.x=x;this.y=y;}  public void affCoord() { System.out.println ("Coordonnees : " + x + " " + y) ; }  private int x, y ;  } Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis par leurs coordonnées (entières) et un nom (caractère). On y prévoira les méthodes suivantes : • constructe constructeur ur pour définir définir les coordonnées coordonnées et le nom d’un d’un objet de type PointNom,

• affCoordNom pour afficher les coordonnées et le nom d’un objet de type PointNom. Écrire un petit programme utilisant la classe PointNom. •

Cet exercice exercice est voisin voisin de de l’exercice l’exercice 61 mais, mais, cette cette fois, fois, les les deux deux classes classes d dispo isposent sent d’un d’un constructeur. Celui de la classe dérivée PointNom doit prendre en charge la construction de l’intégralité de l’objet correspondant, quitte à s’appuyer pour cela sur le constructeur de la classe de base (ce qui est indispensable ici puisque la classe Point ne dispose pas de méthodes d’accès). Rappelons que l’appel du constructeur de la classe de base (fait à l’aide du mot clé super ) doit constituer la première instruction du constructeur de la classe dérivée.

Exerc Exe rcice ice 63 : redéfi red éfinit nitio ion n On dispose de la classe suivante :

class Point   { publicPoint(intx,inty) {this.x=x;this. {this.x=x;this.y=y;} y=y;}   public void affiche()   { System.out.println ("Coordonnees : " + x + " " + y) ; }   private int x, y ;  } Réaliser une classe PointNom, dérivée de Point permettant de manipuler des points définis par leurs coordonnées et un nom (caractère). On y prévoira les méthodes suivantes : • constructe constructeur ur pour définir définir les coordonnées coordonnées et le nom d’un d’un objet de type PointNom,

• affiche affiche pour aff afficher icher les ccoordonn oordonnées ées et le nom d’un obje objett de type Point PointNom. Nom.

 

•

• • •

Cet exercice exercice est voisin voisin de l’exerc l’exercice ice 62. L’écrit L’écriture ure du construc constructeur teur reste reste la même. même. Mais, Mais, cette cette fois, on doit redéfinir la méthode affiche dans la classe dérivée. L’affichage du nom n’y pose aucun problème : System System.ou .out.p t.prin rintt ("Poi ("Point nt de nom " + nom nom + " ") ; En reva revanch nche, e, ilil nous nous faut faut fai faire re appe appell à la la métho méthode de affiche de la classe de base. Pour ce faire, nous employons le mot clé super : super. r.a affiche() ;

Exercice 64 : construction constru ction et initialisation initialisatio n d’une classe dérivée Quels résultats fournit ce programme ?

class A {    public A (int nn)   { System.out System.out.println .println ("Entree Cons Constr tr A - n=" + n + " p=" + p) ;   n = nn ;   System.out.println ("Sortie Constr A - n=" + n + " p=" + p) ;   }   public int n ; // ici, exceptionnellement, pas d'encapsulation   public int p=10 ;  } class B extends A { public B (int n, int pp)   { super (n) ;   System.out.println ("Entree Constr B - n n=" =" + n + " p=" + p + " q=" + q) ;   p = pp ; q = 2*n ;   System.out.println ("Sortie Constr B - n=" + n + " p=" + p + " q=" + q) ;  }   public int q=25 ;  }  public class TstInit  TstInit  { public static void main (String args[])   { A a = new A(5) ;   B b = new B(5, 3) ;   }  } Il faut tenir compte de l’ordre dans lequel ont lieu les initialisations des champs (explicite et implicite) et les appels des constructeurs, à savoir :    

initialisation par défaut des champs de l’objet dérivé (y compris ceux hérités), initialisation explicite des champs hérités, exécution du constructeur de la classe de base, initialisation explicite des champs spécifiques à l’objet dérivé,

 



exécution du constructeur de la classe dérivée.

Exercice Exer cice 67 : les bases du polymorp polym orphis hisme me Quels résultats fournit le programme suivant ?

class A { public void affiche() { S System.out.print ystem.out.print ("Je sui suiss un A ") ; }  } class B extends A {} class C extends A { public void affiche() { S System.out.print ystem.out.print ("Je sui suiss un C ") ; }  } class D extends C{  public void affiche() affiche() { System.out.print ("Je suis un D ") ; }  } class E extends B {} class F extends C {}  public class Poly  { public static void main (String arg[]) { A a = new A(); a.affiche(); System.out.println(); B b = new B(); b.affiche(); a=b;

a.affiche(); System.out.println(); System.out.println();

C c = new C(); c.affiche(); a=c;

a.affiche(); System.out.println(); System.out.println();

D d = new D();

d.affiche();

a=d;

a.affiche();

c=d;

c.affiche(); System.out.println(); System.out.println();

E e = new new E(); E(); e.affiche( e.affiche(); ); a=e;

a.affiche();

b=e;

b.affiche(); System.out.println(); System.out.println();

F f = new F(); f.affiche(); a=f;

a.affiche();

 

c=f;

c.affiche();

} }

Certaines possibilités d’affectation entre objets des types classes  A, B, C , D, E et F ne figurent pas dans le programme ci-dessus. Pourquoi ? En Java, l’une des propriétés du "polymorphisme" est que l’appel d’une méthode est déterminé au moment la nature l’objet effectivement référencé (et non seulement le type dedelal’exécution, référence). suivant C’est pourquoi icide tous les appels de affiche concernant un même objetsuivant fournissent le même message, quel que soit le type de ré référence férence utilisé.

Exercice Exer cice 69 : les limites du polymor pol ymorphis phisme me Soit les classes Point et PointNom ainsi définies :

class Point  { public Point (int x, iint nt y) { this.x = x ; th this.y is.y = y ; }   public static boolean identiques (Point a, Point b) { return ( (a.x==b.x) && (a.y==b.y) ) ; }   public boolean identique (Point a)   { return ( (a (a.x==x) .x==x) && (a. (a.y==y) y==y) ) ; }   private int x, y ;  } class PointNom extends Point  { PointNom (int x, int y, char nom)   { super (x, y) ; this.nom = nom ; }   private char nom ;  } 1. Quels résultats fournit ce programme ? Expliciter les conversions mises en jeu et les règles utilisées pour traiter les différents appels de méthodes :

 public class LimPoly  { public static void main (String args[])   { Point p = new Point (2, 4) ;   PointNom pn1 = new PointNom (2, 4, 'A') ; PointNom pn2 = new PointNom (2, 4, 'B') ;   System.out.println (pn1.identique(pn2)) ; System.out.println (p.identique(pn1)) ; System.out.println (pn1.identique(p)) ; System.out.println (Point.identiques(pn1, pn2)) ;  }  }

 

2. Doter la classe PointNom d’une méthode statique identiques et d’une méthode identique fournissant toutes les deux la valeur true lorsque les deux points concernés ont à la fois mêmes coordonnées et même nom. Quels résultats fournira alors le programme précédent ? Quelles seront les conversions mises en jeu et les règles r ègles utilisées ?

Exercice Exer cice 70 : classe clas se abstrait abst raite e On souhaite disposer d’une hiérarchie de classes permettant de manipuler des figures géométriques. On veut qu’il soit toujours possible d’étendre d’ étendre la hiérarchie en dé dérivant rivant de nouvelles classes mais on souhaite pouvoir imposer que ces dernières dernière s disposent toujours des méthodes suivantes :

• vo void id aff affic iche he (()) • void homot homothetie hetie (doub (double le ccoeff) oeff) • void void rota rotatio tion n (dou (double ble an angle gle)) Écrire la classe abstraite Figure qui pourra servir de classe de base à toutes ces classes. •

Il suffit suffit d’appliqu d’appliquer er les règles règles de définit définition ion d’une d’une classe classe abstrait abstraite. e. On y place place les en-têt en-têtes es des méthodes qu’on souhaite voir redéfinies dans les classes dérivées, en leur associant le mot clé

abstract. Exercice Exer cice 71 : classe clas se abstraite abstra ite et polymorphi polymor phisme sme Compléter la classe abstraite Figure de l’exercice précédent, de façon qu’elle implémente : • une une m mét étho hode de homoRot (double coef, double angle) qui applique à la fois une homothétie et une rotation à la figure, • de métho méthodes des stat statiqu iques es afficheFigures, homothetieFigures et rotationFigures appliquant une même opération (affichage, homothétie ou rotation) à un tableau de figures (objets d’une classe dérivée de Figure). •

Une classe classe abstra abstraite ite peut comport comporter er des définiti définitions ons de méthodes méthodes (non abstra abstraites) ites) qui pourront pourront alors être utilisées par les classes dérivées sans qu’il ne soit nécessaire de les redéfinir (mais on peut toujours le faire !). D’autre part, une classe abstraite peut comporter des méthodes statiques, pour peu que celles-ci ne soient pas abstraites (ce qui n’aurait aucune signification).

Exerc Exe rcice ice 72 : in inter terfa face ce On souhaite disposer de classes permettant de manipuler des figures géométriques. On souhaite pouvoir caractériser celles qui possèdent certaines fonctionnalités en leur demandant d’implémenter des interfaces, à savoir : •  Affichable pour celles qui disposeront d’une méthode void affiche (),

• Tranformab Tranformable le pour celles qui dis disposeron poserontt des deux méthodes su suivant ivantes es : void homothetie (double coeff) void rotation (double angle) • Écrire Écrire les deux interfa interfaces ces Affic Affichable hable et Trans Transforma formable. ble.

 

•

Il suffi suffitt d’appli d’applique querr les règle règles s de défini définitio tion n d’un d’une e interfa interface. ce.

Exercice 73 : comparaison comparais on entre héritage h éritage et objet ob jet membre On dispose de la classe suivante :

class Point  { public Point (doubl (doublee x, double y) { this.x=x ; this.y=y ; }   public void deplace (doubl (doublee dx, double dy) { x+=dx ; y+=dy ; }  public void affiche ()   { System.out System.out.println .println ("Point de coordonnees " + x + " " + y) ; }   public double getX() { return x ; }  public double getY() { return y ; }  private double x, y ;  } On souhaite réaliser une classe Cercle disposant des méthodes suivantes :    

constructeur recevant en argument les coordonnées du centre du cercle et son rayon, deplaceCentre pour modifier les coordonnées du centre du cercle, changeRayon pour modifier le rayon du cercle, getCentre qui fournit en résultat un objet de type Point correspondant au centre du cercle,

qui affiche les coordonnées du centre du cercle et son rayon. affiche 1. Défi Défini nirr la la cl clas asse se Cercle comme classe dérivée de Point . 2. Défi Défini nirr la la cl clas asse se Cercle comme possédant un membre de type Point . 

Dans les deux cas, on écrira un petit pe tit programme mettant en jeu les différentes fonctionnalités de la classe Cercle.