Vous êtes sur la page 1sur 4

01/04/2009

Programmation Orientée Objet


DUT SRC IUT Meaux, année 2009-Module M2.23
TD 5 Java : initiation à la notion de classe, héritage,
polymorphisme
Exercice 4 : Objectifs : classes abstraites, héritage, collections : ArrayList.
Il s'agit dans cet exercice de permettre la création de points, cercles et cylindres. Pour cela, on
considère qu'un cercle étend la notion de point pour caractériser son rayon. De même, un cylindre
étend la notion de cercle.
1) Vous devez implémenter une classe abstraite Forme qui sera la super classe de la classe Point et
donc transitivement des classes Cercle et Cylindre. La classe Forme comporte 3 méthodes : calcul de
l'aire de la forme, calcul du volume de la forme et affichage du nom de la forme, respectivement
“point”, “cercle” et “cylindre” pour nos 3 classes.
2) La classe Point est caractérisée par 2 coordonnées réelles : x,y. La classe doit permettre d'accéder et
de modifier ces coordonnées. Elle implémente également une méthode toString() affichant les
coordonnées du point.
3) La classe Cercle étend la classe Point, elle comporte également une valeur réelle pour son rayon.
Vous devez écrire 2 constructeurs pour cette classe :
• le premier va créer un cercle dont le centre est le point (0,0) et de rayon 0;
• le second comporte des paramètres pour les coordonnées du centre et le rayon.
De même que pour le point, vous devez proposer une méthode toString() affichant toutes les
informations sur le cercle (coordonnées du centre, valeur du rayon). Enfin le cercle propose une
méthode pour le calcul de l'aire (3.14158 * rayon * rayon)
4) La classe Cylindre étend la classe Cercle et comporte une valeur réelle hauteur.
• Implémenter un get et un set pour la hauteur.
• Implémenter les méthodes aire() et volume() pour le cylindre, respectivement
2*aire du cercle + 2 * 3.14159 * rayon * hauteur
et : aire du cercle * hauteur.
• La méthode toString() permet d'obtenir toutes les informations sur le cylindre : centre du
cercle, rayon du cercle et hauteur.
5) Vous devez tester l'implémentation en écrivant une classe FormeTest.
• Une première version comporte un tableau de formes alors que :
• la seconde comporte une ArrayList de formes. Dans la seconde implémentation,
l'itération sur les éléments de la liste se fait par un Iterator.
Dans les deux cas, vous devrez créer :
- un point avec x=5 et y=5
- un cercle avec un rayon de 8.5 et des coordonnées x=10,y=15 pour centre
- un cylindre avec une hauteur de 20, un rayon de 12,5 et des coordonnées x=30,y=30.
- et afficher les coordonnées, les aires, les volumes et le nom des 3 formes
Vous devez obtenir les informations suivantes:

[ 5.0, 5.0]
Aire de Point = 0.0 et volume = 0.0
Centre = [ 10.0, 15.0], Rayon = 8.5
Aire de Cercle = 226.9798775 et volume = 0.0
Centre = [ 30.0, 30.0], Rayon = 12.5, hauteur = 20.0
Aire de Cylindre = 2552.541875 et volume = 9817.46875

Corrigé : fait en prog3. Tu dois l’avoir. Sinon dis le moi je te l’enverrai.


Exercice 5 : Objectifs : collections : ArrayList.
Un collectionneur veut gérer la liste des véhicules qu’il possède. Il collectionne différents types de
véhicules : des autos, des motos et des camions. Pour chaque véhicule, il veut conserver sa marque,
son modèle et sa couleur (exemple Renault Clio rouge…). Il désire :

a. afficher la liste des noms des véhicules qu’il possède,


b. afficher tous les véhicules d’une couleur donnée
c. rechercher s’il possède ou non un véhicule d’une certaine marque et d’un certain
modèle.
d. Vendre un véhicule

1) Proposer une solution orientée objet permettant de représenter toutes les véhicules possibles.
Comment gérer le type du véhicule ?
Corrigé : C’est un exemple intéressant : rien ne nous oblige à créer
une classe véhicule avec une sous-classe par type (auto, moto,
camion). En effet, il n’y a aucune information, ni aucun
traitement spécifique à ces sous-classes. On peut très bien le
gérer avec un attribut qui contient l’un des trois types.
Néanmoins, c’est plus propre de faire des sous-classes et cela
mettra en avant le polymorphisme avec les ListArray.

2) Implanter sous Eclipse en Java la solution à base d’héritage et tester tout d’abord les classes
que vous avez imaginées en instantiant différents objets de votre choix (avec les
constructeurs) pour chacune de celles-ci.
Corrigé :
/////////////////////////// class Camion extends Vehicule {
// La classe véhicule Camion(String marque, String mod, String coul){
/////////////////////////// super(marque, mod, coul) ;
class Vehicule { }
protected String marque, modele,couleur; }
Vehicule(String marque,String mod,String coul){ class Auto extends Vehicule {
this.marque = marque ; Auto(String marque, String mod, String coul) {
// pour rappeler le this super(marque, mod, coul) ;
modele = mod ; }
couleur = coul ; }
} //le programme principal
public void Affiche() { public class Test {
System.out.println("Marque :" + marque) ; public static void main(String[] args) {
System.out.println("Modele :" + modele) ; // test des constructeurs et des appels
System.out.println("Couleur :" + couleur) ; // entre eux (rappel)
} Vehicule v1 = new Vehicule("Renault", "twingo",
} "bleue") ;
//un choix du type de véhicule par sous-classe Auto v2 = new Auto("Peugeot", "504", "blanche") ;
class Moto extends Vehicule { Moto v3 = new Moto("Honda", "CB500", "blanche") ;
Moto(String marque, String mod, String coul) { Camion v4 = new Camion("Berliet","Camion
super(marque, mod, coul) ; Benne","gris") ;
} v1.Affiche() ;
} v2.Affiche() ;
v3.Affiche() ;
v4.Affiche() ;

}
}

3) Le collectionneur ne connaît pas a priori le nombre de véhicules qu’il va posséder. Utilisez les
collections et notamment les ArrayList pour mettre des éléments (véhicules) dans cette liste et
pour l’afficher avec et sans itérateurs.
Corrigé :
La première idée est de déclarer une ArrayList de Véhicule dans le
programme principal et d’utiliser ou non un itérateur pour la
parcourir. Exemple classique dont voici le code du programme
principal :
// Avec une liste array simple
ArrayList<Vehicule> liste =
new ArrayList<Vehicule>() ; // version avec un iterateur ensuite
liste.add(v1) ; liste.add(v2) ; Iterator ite = liste.iterator() ;
liste.add(v3) ; liste.add(v4) ; while (ite.hasNext()) {
for (int i = 0 ; i < liste.size(); i++){ Vehicule tmp = (Vehicule) ite.next();
System.out.println("Vehicule :" + i) ; tmp.Affiche();
liste.get(i).Affiche() ; }
}

4) Créer une classe qui hérite de ArrayList pour pouvoir efficacement répondre aux questions b,
c et d.
Corrigé :
Dans ces question b, c, d, nous avons besoin de fonctions qui
parcourent la liste avec des traitements spécifiques (recherche sur
un modèle uniquement…). Il est alors intéressant de le prendre en
compte en créant une nouvelle classe qui hérite de la classe
ListArray et pour laquelle il deviendra facile de réaliser ces
traitements spécifiques.
import java.util.* ; System.out.println(" index trouvé : " +i ) ;
/////////////////////////// if (i != -1)
// La classe véhicule this.remove(i);
/////////////////////////// }
class Vehicule { }
protected String marque, modele, couleur ;
Vehicule(String marque, String mod, String coul) { ////////////// le programme principal d'appel
this.marque = marque ; // pour rappeler le this public class Test {
modele = mod ; public static void main(String[] args) {
couleur = coul ; // test des constructeurs et des appels entre eux (rappel)
} Vehicule v1 = new Vehicule("Renault", "twingo", "bleue") ;
public void Affiche() { Auto v2 = new Auto("Peugeot", "504", "blanche") ;
System.out.println("Marque :" + marque) ; Moto v3 = new Moto("Honda", "CB500", "blanche") ;
System.out.println("Modele :" + modele) ; Camion v4 = new Camion("Berliet","Camion Benne","gris") ;
System.out.println("Couleur :" + couleur) ;
} v1.Affiche() ; v2.Affiche() ; v3.Affiche() ; v4.Affiche() ;
public String getCouleur() { return couleur ; }
public String getMarque() { return marque ; } // Avec une ListArray simple
public String getModele() { return modele ; } ArrayList<Vehicule> liste = new ArrayList<Vehicule>() ;
}
liste.add(v1) ;liste.add(v2); liste.add(v3) ; liste.add(v4) ;
// un choix du type de véhicule par sous-classes for (int i = 0 ; i < liste.size() ; i++) {
System.out.println("Vehicule :" + i) ;
class Moto extends Vehicule { liste.get(i).Affiche() ;
Moto(String marque, String mod, String coul) { }
super(marque, mod, coul) ;
} // version avec un iterateur ensuite
} Iterator ite = liste.iterator() ;
class Camion extends Vehicule { while (ite.hasNext()) {
Camion(String marque, String mod, String coul) { Vehicule tmp = (Vehicule) ite.next();
super(marque, mod, coul) ; tmp.Affiche();
} }
}
class Auto extends Vehicule { // Avec une sous-classe qui hérite de la classe ArrayList
Auto(String marque, String mod, String coul) { ListeVehicules liste1 =new ListeVehicules();
super(marque, mod, coul) ;
} // on met 4 éléments dans la liste qui sont des sous-classes
} de la classe Vehicule
// Une classe qui hérite de la Classe ArrayList liste1.add(v1); liste1.add(v2);liste1.add(v3);liste1.add(v4) ;
class ListeVehicules extends ArrayList<Vehicule> {
public void vendre(){ // Affichage des éléments de la liste avec une boucle simple
System.out.println("vendre") ; sur le nombre d'éléments de la liste
} for (int i = 0 ; i < liste1.size() ; i++) {
public void vehicule_couleur(String coul){ System.out.println("Vehicule :" + i) ;
System.out.println("+++++++++++++++++") ; liste1.get(i).Affiche() ;
System.out.println("Vehicule de couleur : " + coul) ; }
Iterator ite = this.iterator() ;
while (ite.hasNext()) { // affichage des élements avec un iterateur
Vehicule tmp = (Vehicule) ite.next(); Iterator ite1 = liste1.iterator() ;
if (tmp.getCouleur() == coul) tmp.Affiche(); while (ite1.hasNext()) {
} Vehicule tmp = (Vehicule) ite1.next();
} tmp.Affiche();
public void recherche_vehicule(String mark, String mod){ }
System.out.println("+++++++++++++++++") ;
System.out.println("Vehicule de marque : " + mark + " de // affichage des véhicules d'une couleur
modele " + mod) ; liste1.vehicule_couleur("blanche") ;
Iterator ite = this.iterator() ;
while (ite.hasNext()) { // recherche d'un véhicule donné
Vehicule tmp = (Vehicule) ite.next(); liste1.recherche_vehicule("Renault", "twingo");
if ( (tmp.getMarque() == mark) &&
(tmp.getModele() == mod) ) tmp.Affiche(); // suppression d'un véhicule
} liste1.supprimer(v1) ;
} Camion v5 = new Camion("Berliet","toto","vert") ;
public void supprimer(Vehicule v) { liste1.supprimer(v5) ;
System.out.println("+++++++++++++++++") ; }
System.out.println("Supression d'un véhicule") ; }
int i = this.lastIndexOf(v) ;
5) Créer une interface graphique permettant d’afficher chaque véhicule présent dans la liste sous forme d’une
liste de boutons sur lesquels on peut cliquer pour afficher toutes les informations concernant le véhicule
sélectionné.

Corrigé : A faire l’année prochaine

Exercice 6 : Objectifs : Manipulation de chaînes de caractères, lecture sur l’entrée standard Durée 2H
Palindrome :
0) Définition d'un palindrome: Chaîne de caractères qui peut être lu indifféremment de gauche à droite ou de droite
à gauche. Exemple : totot est un palindrome
1) Ecrire un programme qui vérifie qu'une chaîne de caractères est un palindrome
2) Dans la cas d'une phrase, on dit quelle est un palindrome si la chaîne obtenue en supprimant les espaces en est un.
Généraliser le programme précédent de façon à vérifier si une phrase est un palindrome.
Exemple : Esope reste ici et se repose. Donne la chaîne (en supprimant les espaces) :
Esoperesteicietserepose
qui est un palindrome
Indications :
a) Pour saisir une chaîne de caractères, vous pouvez utiliser la méthode saisir() suivante:
private String saisir() {
System.out.println("Saisir le mot ou la phrase à tester :");
BufferedReader entreeClavier = new BufferedReader(new InputStreamReader(System.in));try {
String saisie = entreeClavier.readLine();
return saisie;
} catch(Exception e) {
System.out.println("Erreur lors de la saisie");
return null;
}
}
b) Aidez-vous du cours pour la comparaison des chaînes de caractères. Potentiellement vous disposez de 3 approches:
opérateur == , méthode compareTo(), méthode equals().
Lesquelles marchent ?.

Corrigé : fait en prog3. Tu dois l’avoir. Sinon dis le moi je te l’enverrai.