Classe, surchage, héritage et polymorphise
Fermé
tachag
Messages postés
46
Date d'inscription
samedi 11 décembre 2004
Statut
Membre
Dernière intervention
19 novembre 2005
-
3 août 2005 à 22:33
mamiemando Messages postés 33499 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 27 janvier 2025 - 30 août 2015 à 13:16
mamiemando Messages postés 33499 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 27 janvier 2025 - 30 août 2015 à 13:16
5 réponses
mamiemando
Messages postés
33499
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
27 janvier 2025
7 816
4 août 2005 à 01:54
4 août 2005 à 01:54
Toutes les réponses sont là :
http://www.commentcamarche.net/java/javafonc.php3
http://www.commentcamarche.net/java/javafonc.php3
tachag
Messages postés
46
Date d'inscription
samedi 11 décembre 2004
Statut
Membre
Dernière intervention
19 novembre 2005
6 août 2005 à 22:53
6 août 2005 à 22:53
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]
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]
mamiemando
Messages postés
33499
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
27 janvier 2025
7 816
8 août 2005 à 01:46
8 août 2005 à 01:46
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.
tachag
Messages postés
46
Date d'inscription
samedi 11 décembre 2004
Statut
Membre
Dernière intervention
19 novembre 2005
8 août 2005 à 02:23
8 août 2005 à 02:23
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();
}
}
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();
}
}
Winou
>
tachag
Messages postés
46
Date d'inscription
samedi 11 décembre 2004
Statut
Membre
Dernière intervention
19 novembre 2005
10 mars 2008 à 14:33
10 mars 2008 à 14:33
Salut à tous.
En Java, une surcharge toute simple à faire est celle de la fonction toString().
De base, cette fonction renvoit une chaîne de caractères correspondant au type de l'objet (inutile en général), mais il est facilement possible de la surcharger pour lui faire afficher, par l'exemple, l'ensemble des attributs de la classe, séparés par un espace ou un retour à la ligne.
En espérant avoir été utile.
++
En Java, une surcharge toute simple à faire est celle de la fonction toString().
De base, cette fonction renvoit une chaîne de caractères correspondant au type de l'objet (inutile en général), mais il est facilement possible de la surcharger pour lui faire afficher, par l'exemple, l'ensemble des attributs de la classe, séparés par un espace ou un retour à la ligne.
public String toString() { return this.attribut1 + " " + this.attribut2 + " " + ... ; } ou encore public String toString() { String contenu; contenu = this.attribut1 + " " + this.attribut2 + ... ; contenu += (char)13; //retour à la ligne return contenu; }
En espérant avoir été utile.
++
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
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
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
tachag
Messages postés
46
Date d'inscription
samedi 11 décembre 2004
Statut
Membre
Dernière intervention
19 novembre 2005
4 août 2005 à 00:57
4 août 2005 à 00:57
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.
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.
leon91490
Messages postés
166
Date d'inscription
mardi 19 mai 2009
Statut
Membre
Dernière intervention
9 septembre 2017
47
2 août 2013 à 20:43
2 août 2013 à 20:43
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.
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.
mamiemando
Messages postés
33499
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
27 janvier 2025
7 816
Modifié par mamiemando le 30/08/2015 à 13:18
Modifié par mamiemando le 30/08/2015 à 13:18
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 :
Bonne chance
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