Vous êtes sur la page 1sur 6

Exercice 1 :

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 2 :
On dispose de la classe suivante :
class Point
{ public void setPoint (int x, int 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 les coordonnées et le nom d’un objet de type PointNom.
Écrire un petit programme utilisant la classe PointNom.

Exercice 3 :
On dispose de la classe suivante (disposant cette fois d’un constructeur) :
class Point
{ public Point (int x, int 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 :
• constructeur pour définir les coordonnées et le nom 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.
Exercice 4 :
On dispose de la classe suivante :
class Point
{ public Point (int x, int y) { this.x = x ; this.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 :
• constructeur pour définir les coordonnées et le nom d’un objet de type PointNom,
• affiche pour afficher les coordonnées et le nom d’un objet de type PointNom.
Exercice 5 :
Quels résultats fournit ce programme ?
class A
{
public A(int nn)
{ System.out.println ("Entree Constr 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 + " 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
{ public static void main (String args[])
{ A a = new A(5) ;
B b = new B(5, 3) ;
}
}
Exercice 6 :
Quels résultats fournit le programme suivant ?
class A
{ public void affiche()
{ System.out.println ("Je suis un A") ;
}
}
class B extends A { }
class C extends A
{ public void affiche()
{ System.out.println ("Je suis un C") ;
}
}
class D extends C
{ public void affiche()
{ System.out.println ("Je suis un D") ;
}
}
class E extends B {}
class F extends C {}
public class DiagHeri
{ public static void main (String arg[])
{ A a = new A() ; a.affiche() ;
B b = new B() ; b.affiche() ;
C c = new C() ; c.affiche() ;
D d = new D() ; d.affiche() ;
E e = new E() ; e.affiche() ;
F f = new F() ; f.affiche() ;
}
}
Exercice 7 :
Quels résultats fournit le programme suivant ?
class A
{ public void f(double x) {
System.out.print ("A.f(double=" + x +") ") ;
}
}
class B extends A {}
class C extends A
{ public void f(long q) { System.out.print ("C.f(long=" + q + ") ") ; }
}
class D extends C
{ public void f(int n) { System.out.print ("D.f(int=" + n + ") ") ; }
}
class E extends B {}
class F extends C
{ public void f(float x) { System.out.print ("F.f(float=" + x + ") ") ; }
public void f(int n) { System.out.print ("F.f(int=" + n + ") ") ; }
}
public class Surdf
{ public static void main (String arg[])
{ byte bb=1 ; short p=2 ; int n=3 ; long q=4 ;
float x=5.f ; double y=6. ;
A a = new A() ; a.f(bb) ; a.f(x) ; System.out.println() ;
B b = new B() ; b.f(bb) ; a.f(x) ; System.out.println() ;
C c = new C() ; c.f(bb) ; c.f(q) ; c.f(x) ; System.out.println() ;
D d = new D() ; d.f(bb) ; c.f(q) ; c.f(y) ; System.out.println() ;
E e = new E() ; e.f(bb) ; e.f(q) ; e.f(y) ; System.out.println() ;
F f = new F() ; f.f(bb) ; f.f(n) ; f.f(x) ; f.f(y) ; f.f(p) ;
}
}
Les Bases du Polymorphisme
Exercice 8 :

Quels résultats fournit le programme suivant ?


class A
{ public void affiche() { System.out.print ("Je suis un A ") ; }
}
class B extends A {}
class C extends A
{ public void affiche() { System.out.print ("Je suis un C ") ; }
}
class D extends C
{ public void 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() ;
C c = new C() ; c.affiche() ;
a = c ; a.affiche() ; System.out.println() ;
D d = new D() ; d.affiche() ;
a = d ; a.affiche() ;
c = d ; c.affiche() ; System.out.println() ;
E e = new E() ; e.affiche() ;
a = e ; a.affiche() ;
b = e ; b.affiche() ; 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 ?
Exercice 9 :
Quels résultats fournit le programme suivant ?
class A
{ public void f(double x) { System.out.print ("A.f(double=" + x +") ") ; }
}
class B extends A {}
class C extends A
{ public void f(long q) { System.out.print ("C.f(long=" + q + ") ") ; }
}
class D extends C
{ public void f(int n) { System.out.print ("D.f(int=" + n + ") ") ; }
}
class F extends C
{ public void f(float x) { System.out.print ("F.f(float=" + x + ") ") ; }
public void f(int n) { System.out.print ("F.f(int=" + n + ") ") ; }
}
public class PolySur
{ public static void main (String arg[])
{ byte bb=1 ; short p=2 ; int n=3 ; long q=4 ;
float x=5.f ; double y=6. ;
System.out.println ("** A ** ") ;
A a = new A() ; a.f(bb) ; a.f(x) ; System.out.println() ;
System.out.println ("** B ** ") ;
B b = new B() ; b.f(bb) ; b.f(x) ; System.out.println() ;
a = b ; a.f(bb) ; a.f(x) ; System.out.println() ;
System.out.println ("** C ** ") ;
C c = new C() ; c.f(bb) ; c.f(q) ; c.f(x) ; System.out.println() ;
a = c ; a.f(bb) ; a.f(q) ; a.f(x) ; System.out.println() ;
System.out.println ("** D ** ") ;
D d = new D() ; d.f(bb) ; c.f(q) ; c.f(y) ; System.out.println() ;
a = c ; a.f(bb) ; a.f(q) ; a.f(y) ; System.out.println() ;
System.out.println ("** F ** ") ;
F f = new F() ; f.f(bb) ; f.f(n) ; f.f(x) ; f.f(y) ;
System.out.println() ;
a = f ; a.f(bb) ; a.f(n) ; a.f(x) ; a.f(y) ; System.out.println() ;
c = f ; c.f(bb) ; c.f(n) ; c.f(x) ; c.f(y) ;
}
}
Les limites du polymorphisme
Exercice 10 :
Soit les classes Point et PointNom ainsi définies :
class Point
{ public Point (int x, int y) { this.x = x ; this.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.x==x) && (a.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
fournisant 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 utilisées ?
Exercice 11 :
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 la hiérarchie en dérivant de
nouvelles classes mais on souhaite pouvoir imposer que ces dernières disposent toujours
des méthodes suivantes :
• void affiche ()
• void homothetie (double coeff)
• void rotation (double angle)
Écrire la classe abstraite Figure qui pourra servir de classe de base à toutes ces classes.
Exercice 12 :
Compléter la classe abstraite Figure de l’exercice précédent, de façon qu’elle implémente :
• une méthode homoRot (double coef, double angle) qui applique à la fois une homothétie
et une rotation à la figure,
• de méthodes statiques 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).

Interface
Exercice 13 :
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 (),
• Tranformable pour celles qui disposeront des deux méthodes suivantes :
void homothetie (double coeff)
void rotation (double angle)
Écrire les deux interfaces Affichable et Transformable.
Exercice 14 :
On dispose de la classe suivante :
class Point
{ public Point (double x, double y) { this.x=x ; this.y=y ; }
public void deplace (double dx, double dy) { x+=dx ; y+=dy ; }
public void affiche ()
{ System.out.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,
• affiche qui affiche les coordonnées du centre du cercle et son rayon.
1. Définir la classe Cercle comme classe dérivée de Point.
2. Définir la classe Cercle comme possédant un membre de type Point.
Dans les deux cas, on écrira un petit programme mettant en jeu les différentes fonctionnalités
de la classe Cercle.