Modélisation Véhicule Java

Version imprimable

Salut à tous ! :)
Après avoir acheté un livre en JAVA pour apprendre à m’entraîner , j'ai essayé de faire un exercice mais je suis bloqué concernant l'héritage des classes , les classes abstraites.
Je vous met le sujet ci-dessous ainsi que ma solution proposé en espérant avoir de l'aide ce serait super
UN ÉNORME MERCI A LA COMMUNAUTÉ

Aujourd’hui j’ai décidé de me lancer dans la vente. Je vais vendre des deux roues, des
voitures d’occasions, des motos et des camionnettes. Les camions ne m'intéressent pas
pour le moment. Mon associé voit bien plus grand, il veut aussi que l’on vende des
hélicoptères, des drones et des ULM.
Pour chaque véhicule ci dessus, il y aura au minimum, la marque, le modèle, le numéro de
série, la couleur, la date de mise en service. Certains véhicules auront aussi besoin de la
plaque d’immatriculation, du kilométrage, du cylindré et du type de carburant. On veut aussi
connaître l'état du véhicule (quasi neuf, usagé, etc...) ainsi que connaître les défauts (griffe,
pneu usé, coup, etc...). Enfin pour chaque véhicule, on connaîtra son prix hors taxe et TTC.
Mon associé et moi souhaitons avoir un catalogue de nos véhicules. On veut pouvoir ajouter
des véhicules, supprimer des véhicules, modifier des véhicules du catalogue, attention “tout”
n’est pas modifiable pour un véhicule. On veut aussi pouvoir chercher un véhicule par nom
et/ou* par type et/ou par marque. On veut aussi pouvoir rechercher ces véhicules par
plaques d’immatriculation pour certains.

Classe véhicule

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
abstract class Vehicule
    {
        private int matricule;
        private int modele;
        private double prix;
        private static int nb_vehicules = 0;
 
        public int Matricule
        {
            get { return matricule; }
        }
 
        public int Modele
        {
            get { return modele; }
            set { modele = value; }
        }
 
        public double Prix
        {
            get { return prix; }
            set { prix = value; }
        }
 
        public static int Nb_vehicules
        {
            get { return nb_vehicules; }   
        }
 
        public Vehicule(int modele, double prix)
        {
            nb_vehicules++;
            matricule = nb_vehicules;
            this.modele = modele;
            this.prix = prix;
        }
 
        public abstract void Demarrer();
        public abstract void Accelerer();
 
        public override string ToString()
        {
            return "Matricule: " + matricule + " Modéle: " + modele + " Prix: " + prix;
        }        
    }

Classe voiture

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class Voiture {
 
	class Voiture : Vehicule
    {
        public Voiture(int modele, double prix) : base(modele, prix) { }
 
        public override void Demarrer()            //Implémentation de la méthode abstraire Démarrer()
        {
            Console.Out.WriteLine("La voiture démarre....");
        }
 
        public override void Accelerer()         //Implémentation de la méthode abstraire accélérer()
        {
            Console.Out.WriteLine("La voiture Accélére....");
        }
 
        public override string ToString()
        {
            return "Voiture_ "+base.ToString();
        }
    }
}

Classe camion

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class Camion {
	class Camion : Vehicule
    {
        public Camion(int modele, double prix) : base(modele, prix) { }
 
        public override void Demarrer()
        {
            Console.Out.WriteLine("Le camion démarre....");
        }
 
        public override void Accelerer()
        {
            Console.Out.WriteLine("Le camion Accélére....");
        }
 
        public override string ToString()
        {
            return "Camion_ " + base.ToString();
        }
    }
//
}

Main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Program
    {
        static void Main(string[] args)
        {
            Voiture v = new Voiture(2005,200000);
            Console.Out.WriteLine(v);
            v.Demarrer();
            v.Accelerer();
            Camion c = new Camion(2003, 4560000);
            Console.Out.WriteLine(c);
            c.Demarrer();
            c.Accelerer();
            Console.ReadKey();
        }
    }

28/03/2018, 10h51
yildiz-online

C'est du C#, pas du java

Pas mal de choses clochent:

Mauvais design:

-ce n'est pas la responsabilité d'un véhicule de connaître le nombre de véhicules existants.
-le modèle devrait être constant
-le prix n'est pas la responsabilité du véhicule, une fois vendu, ça n'a plus de sens.
-classe anémique, les variables ne sont accédées que par getter/setter

Mauvaise implémentation:

-matricule n'est pas initialisé
-pas de vérification des entrées.
-tout est mutable

Merci oui Effectivement je me suis trompé de langage je remet cela en Java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
///////////////////////////
// La classe véhicule
///////////////////////////
class Vehicule {
protected String marque, modele,couleur;
 Vehicule(String marque,String mod,String coul){
 this.marque = marque ;
 // pour rappeler le this
 modele = mod ;
 couleur = coul ;
 }
public void Affiche() {
 System.out.println("Marque :" + marque) ;
 System.out.println("Modele :" + modele) ;
 System.out.println("Couleur :" + couleur) ;
 }
}
//un choix du type de véhicule par sous-classe
class Moto extends Vehicule {
 Moto(String marque, String mod, String coul) {
 super(marque, mod, coul) ;
 }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Camion extends Vehicule {
 Camion(String marque, String mod, String coul){
 super(marque, mod, coul) ;
 }
}
class Auto extends Vehicule {
 Auto(String marque, String mod, String coul) {
 super(marque, mod, coul) ;
 }
}
//le programme principal
public class Test {
 public static void main(String[] args) {
// test des constructeurs et des appels
// entre eux (rappel)
 Vehicule v1 = new Vehicule("Renault", "twingo",
"bleue") ;
 Auto v2 = new Auto("Peugeot", "504", "blanche") ;
 Moto v3 = new Moto("Honda", "CB500", "blanche") ;
 Camion v4 = new Camion("Berliet","Camion
Benne","gris") ;
 v1.Affiche() ;
 v2.Affiche() ;
 v3.Affiche() ;
 v4.Affiche() ;
}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Avec une liste array simple
 ArrayList<Vehicule> liste =
new ArrayList<Vehicule>() ;
liste.add(v1) ; liste.add(v2) ;
liste.add(v3) ; liste.add(v4) ;
for (int i = 0 ; i < liste.size(); i++){
 System.out.println("Vehicule :" + i) ;
 liste.get(i).Affiche() ;
} 
// version avec un iterateur ensuite
Iterator ite = liste.iterator() ;
while (ite.hasNext()) {
 Vehicule tmp = (Vehicule) ite.next();
 tmp.Affiche();
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import java.util.* ;
///////////////////////////
// La classe véhicule
///////////////////////////
class Vehicule {
protected String marque, modele, couleur ;
 Vehicule(String marque, String mod, String coul) {
 this.marque = marque ; // pour rappeler le this
 modele = mod ;
 couleur = coul ;
 }
public void Affiche() {
 System.out.println("Marque :" + marque) ;
 System.out.println("Modele :" + modele) ;
 System.out.println("Couleur :" + couleur) ;
 }
public String getCouleur() { return couleur ; }
public String getMarque() { return marque ; }
public String getModele() { return modele ; }
}
// un choix du type de véhicule par sous-classes
class Moto extends Vehicule {
 Moto(String marque, String mod, String coul) {
 super(marque, mod, coul) ;
 }
}
class Camion extends Vehicule {
 Camion(String marque, String mod, String coul) {
 super(marque, mod, coul) ;
 }
}
class Auto extends Vehicule {
 Auto(String marque, String mod, String coul) {
 super(marque, mod, coul) ;
 }
}
// Une classe qui hérite de la Classe ArrayList
class ListeVehicules extends ArrayList<Vehicule> {
public void vendre(){
 System.out.println("vendre") ;
 }
public void vehicule_couleur(String coul){
 System.out.println("+++++++++++++++++") ;
 System.out.println("Vehicule de couleur : " + coul) ;
 Iterator ite = this.iterator() ;
 while (ite.hasNext()) {
 Vehicule tmp = (Vehicule) ite.next();
 if (tmp.getCouleur() == coul) tmp.Affiche();
 }
 }
public void recherche_vehicule(String mark, String mod){
 System.out.println("+++++++++++++++++") ;
 System.out.println("Vehicule de marque : " + mark + " de
modele " + mod) ;
 Iterator ite = this.iterator() ;
 while (ite.hasNext()) {
 Vehicule tmp = (Vehicule) ite.next();
 if ( (tmp.getMarque() == mark) &&
(tmp.getModele() == mod) ) tmp.Affiche();
 }
 }
public void supprimer(Vehicule v) {
 System.out.println("+++++++++++++++++") ;
 System.out.println("Supression d'un véhicule") ;
 int i = this.lastIndexOf(v) ;
 
System.out.println(" index trouvé : " +i ) ;
 if (i != -1)
 this.remove(i);
 }
}
////////////// le programme principal d'appel
public class Test {
 public static void main(String[] args) {
// test des constructeurs et des appels entre eux (rappel)
 Vehicule v1 = new Vehicule("Renault", "twingo", "bleue") ;
 Auto v2 = new Auto("Peugeot", "504", "blanche") ;
 Moto v3 = new Moto("Honda", "CB500", "blanche") ;
 Camion v4 = new Camion("Berliet","Camion Benne","gris") ;
 
 v1.Affiche() ; v2.Affiche() ; v3.Affiche() ; v4.Affiche() ;
 
 // Avec une ListArray simple
 ArrayList<Vehicule> liste = new ArrayList<Vehicule>() ;
 
 liste.add(v1) ;liste.add(v2); liste.add(v3) ; liste.add(v4) ;
 for (int i = 0 ; i < liste.size() ; i++) {
 System.out.println("Vehicule :" + i) ;
 liste.get(i).Affiche() ;
 }
 
 // version avec un iterateur ensuite
 Iterator ite = liste.iterator() ;
 while (ite.hasNext()) {
 Vehicule tmp = (Vehicule) ite.next();
 tmp.Affiche();
 }
 
 // Avec une sous-classe qui hérite de la classe ArrayList
 ListeVehicules liste1 =new ListeVehicules();
 
 // on met 4 éléments dans la liste qui sont des sous-classes
de la classe Vehicule
 liste1.add(v1); liste1.add(v2);liste1.add(v3);liste1.add(v4) ;
 
 // Affichage des éléments de la liste avec une boucle simple
sur le nombre d'éléments de la liste
 for (int i = 0 ; i < liste1.size() ; i++) {
 System.out.println("Vehicule :" + i) ;
 liste1.get(i).Affiche() ;
 }
 
 // affichage des élements avec un iterateur
 Iterator ite1 = liste1.iterator() ;
 while (ite1.hasNext()) {
 Vehicule tmp = (Vehicule) ite1.next();
 tmp.Affiche();
 }
 
 // affichage des véhicules d'une couleur
 liste1.vehicule_couleur("blanche") ;
 
 // recherche d'un véhicule donné
 liste1.recherche_vehicule("Renault", "twingo");
 
 // suppression d'un véhicule
 liste1.supprimer(v1) ;
 Camion v5 = new Camion("Berliet","toto","vert") ;
 liste1.supprimer(v5) ;
 }

28/03/2018, 12h02
yildiz-online

Pourquoi peut-on instancier un véhicule?