Classe, surchage, héritage et polymorphise

Ok tout fonctionne maintenant.

Voici le code final, je ne sais pas si c'est bien.

Il ne reste plus que la surcharge. Est-ce que tu as un exemple de surcharge? Quel code devrais je ajouter ?? J'ai de la difficulté...!

Merci de ton aide!!





// Le nom des classes débutent toujours par une majuscule.
// Le nom des variables débutent toujours par une minuscule.
// Si nom composé de plusieurs mots, chaque mot débute par une majuscule.

class Vehicule
{
// définition des attributs
// String : manipulation des chaînes de caractères.
protected String marque;
protected String fonctionnement;


// Constructeur
Vehicule(String saMarque,String sonFonctionnement)
{
marque=saMarque;
fonctionnement=sonFonctionnement;

}

// 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);
}
}

// fin de la classe Vehicule
// Classe Vehicule = super classe

// Héritage : Lorsque nous créons une nouvelle classe (classe dérivée) en se basant sur la classe originale (super classe)
// Héritage : permet la réutilisation de classes déjà prédéfinies.
// Donc, les classes Camion et Avion héritent de la classe Vehicule.


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

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


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("Vitesse:" + vitesse);
System.out.println("");
}

}

// fin de la classe Camion
// Classe Camion : classe dérivée


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

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


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("Hauteur:" + hauteur);
System.out.println("");
}

}

// fin de la classe Avion
// Classe Avion : classe dérivée



// Polymorphisme : Complète l'héritage et fait appel à une méthode unique qui peut se comporter différemment selon le type d'objet auqel elle s'applique.
// Polymorphisme : Exemple : Camion roule et l'Avion vole.
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 Camion ("Ford","Roule","200 km/h");

tonVehicule.getInformation();

monVehicule=new Avion ("Airbus","Vole","40000 pieds");
monVehicule.getInformation();



}


}

Dans le cas de la fonction toString il s'agit d'une redéfinition. La méthode toString redéfinie possède la même signature que la méthode toString de la classe Object. Avec java 1.5 on précède d'ailleurs cette redéfinition par le mot override (et non overload).

souvent en industrie c'est une classe un fichier

Si tu mets plusieures classes dans un fichier... certes tu auras trois classes dans un seul fichier... mais si un jour tu modifies la classe camion sur un fichier

dans le fichier véhicule.cpp tu as véhicule et tu as la classe camion. Un jour on lance la classe camion mais dans camion_v2.cpp toujours héritée de véhicule

donc tu mets véhicule.cpp (dont class camion) et ensuite camion_v2.cpp autant dire que le compilateur va un peu hurler.... et le chef aussi... ce sont les analystes qui assemblent les objets avant de donner à programmer.

Leon tu te rends compte que tu viens de répondre à un message de 2005 :-) ?
Bon et sinon l'approche est simple : généralement un fichier hpp/cpp par classe est un bon découpage (seulement hpp si la classe est template).

Éventuellement si certaines classes sont des détails d'implémentation (c'est-à-dire qui n'ont aucune chance d'être réutilisée ailleurs) d'une classe, on la met dans le même fichier. On peut alors les mettre dans un namespace à part pour souligner qu'elles sont un détail d'implémentation et n'ont pas de raison d'être utilisées ailleurs (ex :

namespace impl { ... }

)

Bonne chance