Encore moi,

Je travaille sur cet exercice, est-ce que je suis sur la bonne voie?

Je vais enregistré cet exercice sous le nom : Véhicules

Classe : véhicule
Sous-classes : camion, auto

Je dois enregistré véhicule, camion et auto avec leur caractéristiques (couleur, année, usagée, neuve) dans des fichiers différents et joindre le tout dans un même fichier en effectuant la surchage, l'héritage et le polymorphisme??

Est-ce que quelqun peut m'aider s.v.p.

Merci.

Toutes les réponses sont là :
http://www.commentcamarche.net/java/javafonc.php3

Bonjour,

Alors voici ce que j'ai fait. J'ai défini une classe, fait l'héritage et le polymorphisme. Par contre, que dois-je ajouter pour ajouter une surchage??

J'ai aussi un message qui dit que j'ai deux erreurs??

Quelqun peut m'aider s.v.p.

Mon code :


[b]class Vehicule
{
// définition des attributs
String marque;
fonctionnement;
caracteristique;

// Constructeur
Vehicule(String saMarque,String sonFonctionnement,String saCaracteristique)
{
marque=saMarque;
fonctionnement=sonFonctionnement;
caracteristique=SaCaracteristique;
}

// définition des méthodes
void getInformation()
{

System.out.println("");
System.out.println("Information sur les véhicules:");
System.out.println("Marque:" + marque);
System.out.println("Fonctionnement:" + fonctionnement);
System.out.println("Caracteristique:" + caracteristique);
}


} // fin de la classe Vehicule



class Camion extends Vehicule
{
// définition des attributs
String vitesse;

// Constructeur
Camion(String saMarque,String sonFonctionnement,String saCaracteristique,String saVitesse)
{
// Appel du constructeur de la classe de base: Vehicule
super(saMarque,sonFonctionnement,saCarateristique);


vitesse=saVitesse;

}

// définition des méthodes
void getInformation()
{
System.out.println("");
System.out.println("Information sur le camion:");
System.out.println("Marque:" + marque);
System.out.println("Fonctionnement:" + fonctionnement);
System.out.println("Caracteristique:" + caracteristique);
System.out.println("Vitesse:" + vitesse);
System.out.println("");
}

} // fin de la classe Camion



class Avion extends Vehicule
{
// définition des attributs
String hauteur;

// Constructeur
Avion(String saMarque,String sonFonctionnement,String saCaracteristique,String saHauteur)
{
// Appel du constructeur de la classe de base: Vehicule
super(saMarque,sonFonctionnement,saCarateristique);


hauteur=saHauteur;

}

// définition des méthodes
void getInformation()
{
System.out.println("");
System.out.println("Information sur l'avion:");
System.out.println("Marque:" + marque);
System.out.println("Fonctionnement:" + fonctionnement);
System.out.println("Caracteristique:" + caracteristique);
System.out.println("Hauteur:" + hauteur);
System.out.println("");
}

} // fin de la classe Avion




public class Information
{
public static void main(String[] args)
{
// tonVehicule va faire référence à un objet de type Camion
// monVehicule va faire référence à un objet de type Avion

Vehicule monVehicule;
Vehicule tonVehicule=new Vehicule ("Ford","Roule","Transporteur", 200);

tonVehicule.getInformation();

monVehicule = new Camion ("Airbus","Vole","Transporteur", 40000);
monVehicule.getInformation();



}


}[/b]

Pour la surcherge crée une méthode portant le même nom mais avec un nombre de paramètres différents. Pour les erreurs donne nous les lignes et le message.

Attention : il en faut pas confondre la surcharge et la redéfinition.

Il y a redéfinition quand une sous-classe définit une méthode qui a exactement la même signature (même nom, même liste ordonnée de types d'attributs) qu'une méthode d'une surclasse. La méthode redéfinie cahce la méthode de la surclasse.
Par exemple, public String toString() qui est définie dans Object est souvent redéfinie dans toutes les classes (toutes les classes sont sous-classes de Object).

Il y a surcharge quand une sous-classe définit une méthode qui a le même nom mais un ensemble de types d'arguments différents d'une méthode d'une surclasse.
Par exemple, soit une classe Parc générique qui définit une méthode public void ajouter(Object o) throws ObjetIncompatibleException.
Admettons qu'une sous-classe ParcDeVehicules définisse une méthode spécialisée dont la signature est "public void ajouter(Vehicule v)". Il s'agit d'une surcharge. En effet, le nom de la méthode est identique (ajouter), mais le type du premier (et seul) paramètre est différent : Vehicule au lieu de Object. Du coup, il est toujours possible que la méthode ajouter(Object o) définie dans Parc soit appelée sur un ParcDeVehicules.

Exemple :
ParcDeVehicules pv= new ParcDeVehicules() ;
Fruit f = new Citron() ;
pv.ajouter(f) ; // la méthode ajouter(Object o) définie dans Parc est appelée sur pv
Vehicule v = new Voiture() ;
pv.ajouter(v) ; // la méthode ajouter(Vehicule v) définie dans ParcDeVehicules est appelée sur pv
Object o = new Voiture() ;
pv.ajouter(o) ; // la méthode ajouter(Object o) définie dans Parc est appelée sur pv
pv.ajouter((Vehicule)o) // la méthode ajouter(Vehicule v) définie dans ParcDeVehicules est appelée sur pv

Pour s'assurer que l'on ne peut ajouter que des instances de Vehicule dans un ParcDeVehicule, il faudra cacher dans ParcDeVehicules la méthode ajouter(Object o) définie dans Parc en redéfinissant cette méthode de la sorte dans ParcDeVehicules :

public void ajouter(Object o) throws ObjectIncompatibleException {
try {
this.ajouter((Vehicule)o);
}
catch ClassCastException {
throw new ObjectIncompatibleException()
}
}

La redéfinition remplace la méthode de la surclasse.
Conséquences sur l'exemple :
ParcDeVehicules pv= new ParcDeVehicules() ;

Fruit f = new Citron() ;
pv.ajouter(f) ; // la méthode ajouter(Object o) définie dans ParcDeVehicules est appelée sur pv et le downcast impropre provoque une exception, qui est capturée pour générer l'exception ObjetIncompatibleException

Vehicule v = new Voiture() ;
pv.ajouter(v) ; // la méthode ajouter(Vehicule v) définie dans ParcDeVehicules est appelée sur pv

Object o = new Voiture() ;
pv.ajouter(o) ; // la méthode ajouter(Object o) définie dans ParcDeVehicules est appelée sur pv, Voiture étant sous-classe de Vehicule, le cast fonctionne et la méthode ajouter(Vehicule v) définie dans ParcDeVehicule est appelée
pv.ajouter((Vehicule)o) // la méthode ajouter(Vehicule v) définie dans ParcDeVehicules est appelée directement sur pv