Académique Documents
Professionnel Documents
Culture Documents
[ 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
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é.
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 ?.