Embed Size (px)
DESCRIPTION
Programmation_orientee_objet
Citation preview
0021266950863 1Programmation orientée objetProgrammation orientProgrammation orientéée objete objet
ELhaidaouiELhaidaoui@@hotmail.comhotmail.com
0021266950863 2
les programmes classiques sont constitués de données utilisées par des traitements.
Les données sont passives, elles subissent les traitements qui représentent la partie
active du programme.
Programmer revient donc à déclarer des variables , puis des procédures pour les manipuler
sans les associer explicitement les unes aux autres.
La programmation orientée objet consiste à modéliser informatiquement un ensemble
d'éléments d'une partie du monde réel (que l'on appelle domaine) en un ensemble d'entités
informatiques. Ces entités informatiques sont appelées objets. Il s'agit de données
informatiques regroupant les principales caractéristiques des éléments du monde réel
(taille, couleur, ...).
IntroductionIntroductionIntroduction
0021266950863 3
PRINCIPE DES MODELES A OBJETSPRINCIPE DES MODELES A OBJETSPRINCIPE DES MODELES A OBJETS
Les modèles à objets ont étés crées pour modéliser le monde réel.
Dans un modèle à objet, toute entité du monde réel est un objet
Un objet est un groupe de données structurées caractérisé par un identifiant uniquereprésentant le monde réel.
0021266950863 4
PRINCIPE DES MODELES A OBJETSPRINCIPE DES MODELES A OBJETSPRINCIPE DES MODELES A OBJETS
Un objet se caractérise par Des attributs.
Exemple : Référence, Désignation, PrixUnitaire et Quantité sont les attributs de l'objet de type ARTICLE.
L'objet est manipulé par des procédures appelées méthodes qui sont caractérisées par
une entête définissant leur nom, les paramètres d'appel et de retour pour chacune d'elle.
Exemple : Nous pouvons définir comme méthodes de l'objet ARTICLE
PrixTtc : Méthode permettant de calculer le prix TTC d'un articleSortieArticle : Méthode permettant de diminuer la quantité en stockEntreeArticle : Méthode permettant d'augmenter la quantité en stock
On ne peut exécuter une méthode sans préciser l'objet sur lequel elle s'applique.
L'ensemble des propriétés d'un objet (attributs et méthodes) constitue un ensemble appelé classe
0021266950863 5
Le concept de classe Le concept de classe Le concept de classe c'est un ensemble de données et de fonctions regroupées dans une même entité.
est une description abstraite d'un objet.
Les fonctions qui opèrent sur les données sont appelées des méthodes.
Instancier une classe consiste à créer un objet sur son modèle.
Entre classe et objet il y a, en quelque sorte, le même rapport qu'entre type et variable.
Java est un langage orienté objet : tout appartient à une classe sauf les variables de typeprimitives.
Pour accéder à une classe il faut en déclarer une instance de classe ou objet.
Une classe comporte sa déclaration, des variables et la définition de ses méthodes.
Une classe se compose en deux parties : un en-tête et un corps. Le corps peut être divisé en 2 sections : la déclaration des données et des constantes et la définition des méthodes.
Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur accessibilité par les composants hors de la classe.
0021266950863 6
Dans ce modèle, un véhicule est représenté par une chaîne de caractères (sa marque) et trois entiers : la puissance fiscale, la vitesse maximale et la vitesse courante. Toutes ces données sont représentatives d'un véhicule particulier, autrement dit, chaque objet véhicule aura sa propre copie de ses données : on parle alors d'attribut d'instance. L'opération d'instanciation qui permet de créer un objet à partir d'une classe consiste précisément à fournir des valeurs particulières pour chacun des attributs d'instance.
La classe est une définition d’objets ayant le même comportement (méthodes), la même structure (mêmes propriétés)
0021266950863 7
Les objets appelés également instances de classe sont générés à partir de la classe que l’on peut qualifier de modèle.
instanciation’L
C’est l’opération qui consiste à classer un objet dans une classe.C’est la création d’un objet à partir d’une classe
L’objet
Les objets contiennent des attributs et des méthodes. Les attributs sont des variables ou des objets nécessaires au fonctionnement de l'objet. En Java, une application est un objet. La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seules les données sont différentes à chaque objet.
Programmer revient donc à décrire des classes d’objets, à caractériser leur structure et leur comportement puis à instancier ces classes pour créer desobjets
0021266950863 8
L'ENCAPSULATION L'ENCAPSULATION L'ENCAPSULATION
L'encapsulation est un mécanisme consistant à rassembler les données et les méthodes
au sein d'une structure en cachant l'implémentation de l'objet,
c'est-à-dire en empêchant l'accès aux données par un autre moyen que les services proposés.
L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet.
L'utilisateur d'une classe n'a pas forcément à savoir de quelle façon sont structurées
les données dans l'objet, cela signifie qu'un utilisateur n'a pas à connaître l'implémentation.
Ainsi, en interdisant l'utilisateur de modifier directement les attributs,
et en l'obligeant à utiliser les fonctions définies pour les modifier (appelées interfaces),
Le masquage des informations
Le concept d’encapsulation
L’Encapsulation
C’est le regroupement dans une même entité appelée objet des données et des traitements. On ne peut atteindre les attributs d’un objet que par l’intermédiaire de sestraitements appelés aussi méthodes ou services
0021266950863 9
héritage hhééritage ritage La notion d'héritage
L'héritage est un principe propre à la programmation orientée objet, permettant de créer
une nouvelle classe à partir d'une classe existante.
Le nom d'"héritage" (pouvant parfois être appelé dérivation de classe) provient du fait que
la classe dérivée (la classe nouvellement créée) contient les attributs et les méthodes de sa
superclasse (la classe dont elle dérive). L'intérêt majeur de l'héritage est de pouvoir définir
de nouveaux attributs et de nouvelles méthodes pour la classe dérivée,
qui viennent s'ajouter à ceux et celles héritées.
0021266950863 10
Véhicule
N° plaquePoids total
Camion Voiture Bus
Charge portes capacité
héritage hhééritage ritage
Généralisation spécialisation
0021266950863 11
Pourquoi hPourquoi héériter ?riter ?
1. Pour ré-utiliser un type existant2. Pour relier des types entre eux3. Pour réduire la programmation
Comment hComment héériter ?riter ?
Par spécialisation
Exprimer qu’un type est un cas particulier d’un autre typeExemple : un Camion est un Véhicule particulière
Par enrichissement
Ajouter des propriétés et des fonctionnalités à un type objet
0021266950863 12
Fonctionnement de l’héritageFonctionnement de lFonctionnement de l’’hhééritageritage
Un objet hérite des champs et des méthodes de tous ses types ascendants
champs héritésméthodes héritées
De plus, un objet dispose des champs et des méthodes de son propre type (nouveaux noms)
champs supplémentairesméthodes supplémentaires
Dans un type, on peut redéfinir une méthode d’un type ascendant
méthodes redéfinies
0021266950863 13
ExempleExempleExemple
un Personnel est un fonctionnaire relevant du Ministère de l’Enseignement Supérieur et de la Recherche ; il est défini par un certain nombre de variables d’instances privées, chacune associée à une méthode publiquede même nom qui permet d’en obtenir la valeur :
CIN (de type String),nom (de type String), anneeNaissance (de type int),
un Enseignant définit une entité pouvant dispenser des cours , cela se définit par un ensemble de variablesd’instance privées avec des méthodes publiques d’accès
matiere (de type String), classeNiveau (de type int),
un Chercheur est une autre entité consacrant une partie de son temps à des recherches ; encore une fois, des variables d’instance privées et des méthodes publiques d’accès :
domaineDeRecherches (de type String), nombrePublications (de type int)
0021266950863 14
héritage hhééritage ritage Hiérarchie des classes
PersonnelCinNomanneeNaissance
Enseignant
MatièreclasseNiveau
Chercheur
domaineDeRecherchesnombrePublications
0021266950863 15
la surchargela surchargela surchargeOn appelle On appelle surchargesurcharge le fait dle fait d’’avoir plusieurs mavoir plusieurs mééthodes qui ont le thodes qui ont le
même nom au sein de la même classemême nom au sein de la même classe
Les exemplaires de la mLes exemplaires de la mééthode ont des paramthode ont des paramèètres difftres difféérentsrents
Ils peuvent avoir le même type de retour Ils peuvent avoir le même type de retour
Par contre, impossible dPar contre, impossible d’’avoir des types de retour diffavoir des types de retour difféérents pour rents pour
les mêmes paramles mêmes paramèètrestres
0021266950863 16
Surcharge : exempleSurcharge : exempleSurcharge : exemple
class Additionneur {class Additionneur {
staticstatic intint somme(somme(intint a, a, intint b) b) // 1// 1{{
return (a+b);return (a+b);}}
staticstatic intint somme(somme(intint a, a, intint b, b, intint c) c) // 2// 2{{
return (a+b+c);return (a+b+c);}}
staticstatic floatfloat somme(somme(floatfloat a, a, floatfloat b) b) // 3// 3{{
return (a+b);return (a+b);}}
staticstatic floatfloat somme(somme(intint a, a, intint b) // interdit b) // interdit àà cause de 1cause de 1{{
return ((return ((floatfloat)a+()a+(floatfloat)b);)b);}}
}}
0021266950863 17
PolymorphismePolymorphismePolymorphisme
On appelle polymorphisme (du grec signifiant « plusieurs formes »)
le fait de dissimuler des traitements différents derrière la même interface.
Le véritable intérêt du polymorphisme est de permettre l’évolution du logiciel avec un
minimum de modifications. Ajoutons une nouvelle classe (octogone) à l’exemple suivant :
0021266950863 18
Figure
DessineToi()
Rectangle
DessineToi ( )
Triangle
DessineToi ( )
Cercle
DessineToi ( )
Octogone
DessineToi ( )
Il suffira de coder la méthode dessineToi dans la classe octogone.
Les objets existants n’ont même pas besoin de savoir que l’on a ajouté une nouvelle forme. Ils ne sont en rien affectés par la modification.
Cet exemple montre l’importance de la dissimulation de l’information.Chaque objet ne doit pas trop en savoir sur les autres.
0021266950863 19
RappelCet objet informatique peut se caractériser ainsi :
Objet = identité + comportement
L’ identité permet de différencier chaque objet parmi les autres.
Le comportement est assuré par des opérations.
Attributs Opérations
0021266950863 20
uneVoiture
Attributs :couleur = bleuepoids = 979 kgpuissance = 12 CVcapacité carburant = 50 lconducteur = Dupontvitesse instantanée = 50 km/h
Opérations :démarrer ()déplacer ()mettreEssence ()
Exemples d'objets
Un objet voiture
Un objet fenêtre Un objet compteuneFenêtre
Attributs :point-sup-gauchepoint-inf-droittextureen-tête
Opérations : activer ()fermer ()réduire (coeff)agrandir (coeff)déplacer (lieu)
unCompte
Attributs :débitcrédittitulaire
Opérations : déposer (somme)retirer (somme)avoirSolde ()
0021266950863 21
ClassePlusieurs objets peuvent posséder une structure et des comportements semblables. La classe factorise les caractéristiques communes de ces objets et, comme son nom le suggère, permet d’en bâtir une classification.
Exemple de classes
Les concepts d'objet et de classe sont interdépendants. En effet, un objet appartient à une classe et une classe décrit la structure et le comportement communs d'objets.
Les classes ont un double rôle :• décrire et classer de façon abstraite des objets • mécanisme d’instanciation).
0021266950863 22
Instance
Classe
Une instance est un représentant particulier d’une classe.
Elle possède les mêmes attributs et les mêmes opérations que les autres instances de la classe.
Les attributs prennent des valeurs distinctes dans chacune des instances.
I n s t a n c e s . . .
L'instanciation est le processus par lequel on crée de nouveaux objetsà partir du modèle défini par une classe.
0021266950863 23
Encapsulation
L’encapsulation consiste à masquer aux utilisateurs d’un objet les détails relevant de son implémentation
(vue interne ou réalisation), et de ne laisser accessible que la vue externe ou interface.
Voiture
Kilométrageniveau d’essence
Démarrer
Se déplacer
Mettre de l’essence
Principe : les attributs ne doivent pas être accessibles de l’extérieur.Seules les opérations sont habilitées à modifier les valeurs des attributs.
0021266950863 24
Encapsulation - avantages
L'intérieur de l'objet est protégé. L'accès direct aux données est impossible. Il faut passer par une méthode (publique) constituant l'interface de l'objet pour avoir accès aux données. Ceci garantit la sécurité et l’intégrité des données.
La complexité est dissimulée. Le programmeur n'a plus à se préoccuper ni du détail dela structure des données, ni de la manière dont sont effectués les traitements.
La maintenance est simplifiée. La portée des modifications est limitée à l’intérieur del’objet concerné. L’implémentation d’une opération peut évoluer sans modifier l’interfacede l’objet.
Les échanges avec l'extérieur sont codifiés. Seules les caractéristiques que l’on souhaite offrir aux utilisateurs potentiels de l’objet figurent dans la partie externe.Cet interface constitue un contrat entre l’objet et ses clients, c’est-à-dire entre le concepteur et ses utilisateurs.
0021266950863 25
Héritage
L'héritage est le mécanisme de transmission des propriétés d'une sur-classevers ses sous-classes.
Compte d'épargne
CréditdébitTaux
déposerretireravoirSoldecalculerIntérêts
Compte
créditdébit
déposerretireravoirSolde
Compte d'épargne
TauxcalculerIntérêts
Compte
créditdébit
déposerretireravoirSolde
L’héritage évite la duplication et facilite la réutilisation.
0021266950863 26
ConstructeurConstructeurConstructeur
Méthode spéciale, à mi chemin entre la méthode de classe et la méthoded'instance chargée de créer un nouvel objet en mémoire et d'initialiser son état.
0021266950863 27
0021266950863 28
Un destructeur permet d'exécuter du code lors de la libération, par le garbage
collector, de l'espace mémoire occupé par l'objet.
En Java, les destructeurs appelés finaliseurs (finalizers), sont
automatiquement appellés par le garbage collector.
Pour créer un finaliseur, il faut redéfinir la méthode finalize() héritée de la
classe Object.
DestructeurDestructeurDestructeur
0021266950863 29
Héritage et visibilitéHHééritage et visibilitritage et visibilitéé
Une classe fille hUne classe fille héérite des attributs et mrite des attributs et mééthodes public(thodes public(PubliquesPubliques) )
et et ProtectedProtected((protprotééggééeses) de la classe m) de la classe mèère, Elle nre, Elle n’’hhéérite pas des rite pas des
attributs et mattributs et mééthodes thodes privateprivate ((PrivPrivééeses) La classe m) La classe mèère ne voit que re ne voit que
ce qui est public dans la classe fille.ce qui est public dans la classe fille.
Un objet dUn objet d’’une classe mune classe mèère nre n’’hhéérite pas des attributs et mrite pas des attributs et mééthodes thodes
de ses classes filles.de ses classes filles.
0021266950863 30
La classe ObjectLa classe La classe ObjectObject
La classe La classe ObjectObject est la classe mest la classe mèère dont hre dont hééritent toutes les ritent toutes les
autres classes.autres classes.
Toute classe dToute classe dééfinie en Java, que ce soit par lfinie en Java, que ce soit par l’’utilisateur ou utilisateur ou
dans un package de ldans un package de l’’API, hAPI, héérite de la classe rite de la classe ObjectObject
toute classe htoute classe héérite des mrite des mééthodes de la classe thodes de la classe ObjectObject
0021266950863 31
Les Interfaces (Héritage Multiple)Les Interfaces (HLes Interfaces (Hééritage Multiple)ritage Multiple)
0021266950863 32
L’implémentationLL’’implimpléémentationmentation
0021266950863 33
La VisibilitéLa VisibilitLa Visibilitéé
PublicPublic
Accessible par toutes les classes de tous les packages.Accessible par toutes les classes de tous les packages.
ProtectedProtected
Permet lPermet l’’accaccèès s àà la ressource par les classes dla ressource par les classes déérivrivéés(ces dernis(ces dernièères res peuvent être situpeuvent être situéées dans un autre package) et toutes du même es dans un autre package) et toutes du même package.package.
PrivatePrivate
Les attributs qui sont dLes attributs qui sont dééfinis avec lfinis avec l’’attribut attribut privateprivate, ne sont pas , ne sont pas accessible accessible àà partir dpartir d’’autres classes ni par les sousautres classes ni par les sous--classes.classes.
0021266950863 34
AbstractAbstract
IntIntéérêtrêt
0021266950863 35
0021266950863 36
0021266950863 37
0021266950863 38
0021266950863 39
0021266950863 40
TP 1 – Création de la Classe Salarie.
Objectif :
Concrétiser les concepts :Classe , les objets , les membres ( propriétés , méthodes ) et l'encapsulation
Cahier des Charges :
Un salarie est décrit par ses données membres:
Un matriculeUn statut (Cadre, Employé, Agent de maîtrise)Un serviceUn nomUn salaire.
On peut connaître le salaire d’un Employé par la fonction membre CalculSalaire().
0021266950863 41
Version A , une Classe Simple sans « encapsulation » :
Définir une classe Salarie avec ses données membres et deux méthodes :
- une méthode membre, CalculSalaire() : - qui renvoie le calcul du salaire annuel (salaire * 1.2)*12- une méthode d’affichage des infos Affichage()
Salarie-----
m_iMatriculem_cStatutm_sServicem_sNomm_dSalaire
: int: char: String: String: double
++
CalculSalaire ()Affichage ()
: double: void
0021266950863 42
Quelques indications :
Instanciation
Déclaration de la variable objet :Exemple :
Salarie salarie ; // réservation d' une zone mémoire
Instanciation de la classe (création d’un objet) : Avec l’instruction new
Exemple :
salarie = new Salarie( ) ; // la référence de l'objet est valable
Déclaration et instanciation sur la même instructionExemple :
Salarie salarie = new Salarie( );
0021266950863 43
Aide à la solution Version A :Il faut une classe Salarie
public class Salarie{ int m_nMatricule; // public par défaut donc pas d’encapsulation…}
il faut une méthode (ou fonction) pour le salaire
Double CalculSalaire( ) {…return…}
il faut une méthode (ou fonction) pour l’affichage
Double Affichage( ) {System.out.println……}
0021266950863 44
Il faut aussi une classe de test pour dérouler un scénario activant des objets Particuliers de cette classe : créons deux salariés et imprimons les !!!
public class Application{
public static void main (String[] args) // console DOS{
Salarie salarie;salarie = new Salarie( );// affectation des propriété // elles sont publiques )salarie.m_nMatricule = 1;…salarie.Affichage() ;…
}}
0021266950863 45
public class Salarie {
int m_iMatricule;char m_cStatut;String m_sService;String m_sNom;double m_dSalaire;
double CalculSalaire(){
return (m_dSalaire * 1.20 * 12);}
void Affichage(){
System.out.println("Matricule : " + m_iMatricule +"\nNom : " + m_sNom +"\nStatut : " + m_cStatut +"\nService : " + m_sService);
System.out.println ("Salaire Annuel : " + (CalculSalaire()) + " E");}
}
0021266950863 46
public class Application {public static void main(String[] args){Salarie salarie1;salarie1 = new Salarie();salarie1.m_iMatricule = 1;salarie1.m_cStatut = 'C';salarie1.m_sNom = "Martin";salarie1.m_sService = "Bip";salarie1.m_dSalaire = 10000;
salarie1.Affichage();
Salarie salarie2 = new Salarie();salarie2.m_iMatricule = 2;salarie2.m_cStatut = 'C';salarie2.m_sNom = "Paul";salarie2.m_sService = "Bip";salarie2.m_dSalaire = 10000;
salarie2.Affichage();}
}
0021266950863 47
0021266950863 48
Version B : Gestion de la classe salarié avec encapsulation
Définition d’une classe Salarie avec :
- ses données membres- ses méthodes d’accès aux données membres- ses constructeurs et destructeurs
Salarie-----
m_iMatriculem_cStatutm_sServicem_sNomm_dSalaire
: int: char: String: String: double
+++++++++++++
CalculSalaire ()Affichage ()getIMatricule ()getCStatut ()getSService ()getSNom ()getDSalaire ()setIMatricule (int newM_iMatricule)setCStatut (char newM_cStatut)setSService (String newM_sService)setSNom (String newM_sNom)setDSalaire (double newM_dSalaire)SALARIE ()
: double: void: int: char: String: String: double: void: void: void: void: void
0021266950863 49
Accès aux données membre des objets :
On ne peut pas accéder directement aux données membre, c’est le concept d’encapsulation.Ilfaut
Donc définir à l’intérieur de la classe employé des méthodes d’accès à ces données.
En général dans les langages Orienté objet ces méthodes se nomment get pour la lecture
et set pour l’écriture.
Exemple : Get_Matricule() et Set_Matricule(……..)
En Java les méthodes get et set porte le même nom, celui de la donnée membre (par convention)
Matricule( ) et Matricule(…..)
Les données membres sont déclarées en private dans la classe, par ce mot clé elles ne sont
accessibles
que dans le corps de la classe, on ne peut les consulter ou les modifier que si la classe définit une
méthode permettant cette consultation ou cette modification. Par opposition au mot clé public oùles
données membres sont accessibles partout où la classe est accessible.
0021266950863 50
Constructeur et destructeur
En Java, le mécanisme d’instanciation attribut par défaut une valeur à chaque
variable d’instance en fonction de son type (null pour une variable de type String), en
Effet aucune variable d’instance ne peut être indéterminée.
Cette instanciation par défaut convient rarement aux spécifications de la classe.
Le programmeur peut définir lui-même l’instanciation qui convient en définissant un
constructeur. Un constructeur est une méthode spéciale, qui spécifie les opérations
à effectuer à l’instanciation.
En Java deux types de constructeurs, un par défaut et un d’initialisation.
Le destructeur est une méthode particulière qui permet lorsqu’il est activé de retirer
(ou nettoyer la mémoire lorsque l’objet n’est plus utilisé).On utilise la méthode finalize
0021266950863 51
Aide à la Solution :
Voici la gestion de l'encapsulation pour le matricule de la classe salarié
// Les attributs doivent être déclarés privateprivate int m_iMatricule ;
// Méthodes d'accès aux données membres, par convention portent le même nom quela variable// lecture ( get )public int Matricule() {return m_iMatricule; // on retourne un entier , le matricule}
// écriture ( put )public void Matricule(int iMatricule){
// on a besoin d'un paramètre : m_iMatricule = iMatricule; // le nouveau matricule
// pas de return }Pour le test on peut utiliser les différents constructeurs puis on détruit les objets avefinalize( )
0021266950863 52
public class Application {public static void main (String[] args) {// 1er salarie : constructeurs par défaut Salarie salarie1 = new Salarie() ;
// affichage// destruction objet salarie1// 2eme salarie : constructeurs completSalarie salarie2;salarie2 = new Salarie(2,"Martin", .....);le constructeur dans la classe Salarie aura comme forme :
public Salarie(int Mat, String Nom, char Sta, String Ser, double Sal){m_iMatricule = Mat;m_sNom = Nom ;.....}
// affichage// destruction objet salarie2// 3eme salarié : utilisation des méthodes d'accès aux attributs privésSalarie salarie3 = new Salarie(); // Instanciationsalarie3.matricule(3); // affectation du matriculesalarie3.nom("DUPONT"); // affectation du nom// affichage // destruction objet salarie3
}
0021266950863 53
public class Salarie{
private int m_iMatricule;private String m_sNom;private char m_cStatut;private String m_sService;protected double m_dSalaire;
//Fonctions Set...
public void Matricule(int Mat){m_iMatricule = Mat;}public void Nom(String Nom){m_sNom = Nom.toUpperCase();}public void Statut(char Sta){m_cStatut = Sta;}public void Service(String Ser){m_sService = Ser;}public void Salaire(double Sal){m_dSalaire = Sal;}
//Fonctions Get...
public int Matricule(){return m_iMatricule;}public String Nom(){return m_sNom;}public char Statut(){return m_cStatut;}public String Service(){return m_sService;}public double Salaire(){return m_dSalaire;}
// Constructeur par défautpublic Salarie(){m_iMatricule = 0;m_sNom = "";m_cStatut = ' ';m_sService = "";m_dSalaire = 0;
}
0021266950863 54
// Constructeurpublic Salarie(int Mat, String Nom, char Sta, String Ser, double Sal){
m_iMatricule = Mat;m_sNom = Nom.toUpperCase();m_cStatut = Sta;m_sService = Ser;m_dSalaire = Sal;
}//destructeursprotected void finalize(){
System.out.println ("destruction de l'objet " +m_sNom);}//Fonctions d'affichagepublic void Affichage(String NomObjet){
System.out.println("\nObjetSalarie : " + NomObjet);System.out.println("Matricule : " + m_iMatricule +
"\nNom : " + m_sNom +"\nStatut : " + m_cStatut +"\nService : " + m_sService);
System.out.println ("Salaire Annuel : " + (CalculSalaire()) + " E");}public double CalculSalaire(){
return (m_dSalaire * 1.20 * 12);}
}
0021266950863 55
public class Application2 {public static void main(String[] args) {
Salarie salarie1 = new Salarie();salarie1.Affichage("salarie 1");salarie1.finalize();
Salarie salarie2 = new Salarie(2,"Marcel DURANT",'C',"BIP",10000.00);salarie2.Affichage("salarie 2");salarie2.finalize();
Salarie salarie3 = new Salarie();salarie3.Matricule(3);salarie3.Nom("Roger Dupont");salarie3.Statut('C');salarie3.Service("BIP");salarie3.Salaire(1000.00);salarie3.Affichage("salarie 3");salarie3.finalize();
}}
0021266950863 56
0021266950863 57
TP 2 – Création de la Classe Commercial.Objectif : L’héritage et le polymorphisme
Cahier des Charges :On dérive la classe Salarié par une classe Commercial, la classe Salarié est la classe générique et la classe Commercial est la classe spécialisée ou spécifique.En plus des données membres Salarié, la classe Commercial a comme données membres :
Un Chiffre d’affaireUn taux de commission
Les méthodes sont les même.La méthodes CalculSalaire intègre un mode de calcul différent, on ajoute au salaire le calcul de la commission (CA * Taux/100).
Schéma : Définition d’une classe Commercial avec ses données membres et une méthode CalculSalaireSalarie
----#
m_iMatriculem_cStatutm_sServicem_sNomm_dSalaire
: int: char: String: String: double
+++++++++++++
CalculSalaire ()Affichage ()getIMatricule ()getCStatut ()getSService ()getSNom ()getDSalaire ()setIMatricule (int newM_iMatricule)setCStatut (char newM_cStatut)setSService (String newM_sService)setSNom (String newM_sNom)setDSalaire (double newM_dSalaire)SALARIE ()
: double: void: int: char: String: String: double: void: void: void: void: void
<<extend>>Commercial
--
m_dChiffreAffairem_iTauxCommission
: double: int
++++
getITauxCommission ()setITauxCommission (int newM_iTauxCommission)getDChiffreAffaire ()setDChiffreAffaire (double newM_dChiffreAffaire)
: int: void: double: void
Construire la classe Commercial qui hérite de la classe Salarie
0021266950863 58
Aide à la solutionclass Salarie // idem TP 1 Version Bclass Commercial : utiliser Extends pour assurer l'héritage de Salarie// Déclaration des données membres spécifiques de commercial se rajoutant à celles de salariéprivate double m_dChiffre;…
// Méthodes d'accès aux données membrespublic int Commission()
{return m_nCommission;
…}// Constructeur par défaut de la classe salariesuper( ) ; // appel au constructeur par défaut de la classe mère
m_nCommission = 0;…
}// Constructeur d'initialisationpublic Commercial(int nMatricule, … , // rajouter les nouvelle propriétés{
super( …);m_nCommission = nCommission;…}
// Méthodes de l'objetpublic String CalculSalaire( ){ // intégration des commissions…}
Classe d’Application:Prévoir deux salariés et un ou deux commerciauxLes instancier avec les constructeurs adéquatsLes afficher notamment calculSalaire( ) pour mettre en oeuvre le polymorphisme
0021266950863 59
public class Commercial extends Salarie{
private double m_dChiffre;private int m_nCommission;
public double Chiffre(){return m_dChiffre;}public int Commission(){return m_nCommission;}
public void Chiffre (double dChiffre){m_dChiffre=dChiffre;}public void Commission (int nCommission){m_nCommission=nCommission;}
//constructeur commercial nullpublic Commercial(){
super();m_nCommission=0;m_dChiffre=0.0;
}//constructeur commercial conforme
public Commercial (int nMatricule, String sNom, char cStatut, String sService, double dSalaire, double dChiffre, int nCommission)
{//super fait ref à la classe mère Salariesuper(nMatricule, sNom, cStatut, sService, dSalaire);m_dChiffre = dChiffre;m_nCommission = nCommission;
}protected void finalize(){super.finalize();}
public double CalculSalaire(){
return (m_dSalaire + (m_dChiffre*m_nCommission/100) * 1.20 * 12);}
}
0021266950863 60
public class Application {public static void main(String[] args) {
Salarie salarie1 = new Salarie();salarie1.Affichage("salarie 1");salarie1.finalize();
Salarie salarie2 = new Salarie(2,"Marcel DURANT",'C',"BIP",10000.00);salarie2.Affichage("salarie 2");salarie2.finalize();Salarie salarie3 = new Salarie();salarie3.Matricule(3);salarie3.Nom("Roger Dupont");salarie3.Statut('C');salarie3.Service("BIP");salarie3.Salaire(1000.00);salarie3.Affichage("salarie 3");salarie3.finalize();
Commercial salarie4 = new Commercial(2,"Etienne,Marcel",'C',"BIP",1000.00,1000.00,5);salarie4.Affichage("salarie 4");salarie4.finalize();Commercial salarie5 = new Commercial();
salarie5.Matricule(3);salarie5.Nom("Aime Rene");salarie5.Statut('C');salarie5.Service("BIP");salarie5.Salaire(1000.00);salarie5.Chiffre(100.00);salarie5.Commission(5);salarie5.Affichage("salarie 5");salarie5.finalize();
}}
0021266950863 61
