ELhaidaoui@hotmail.

com

Programmation orient ée objet

orientée
0021266950863 1
 Introduction
Introduction

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, ...).

0021266950863 2
 PRINCIPE
PRINCIPE DES
DES MODELES
MODELES A
A OBJETS
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 unique

représentant le monde réel.

0021266950863 3
 PRINCIPE
PRINCIPE DES
DES MODELES
MODELES A
A OBJETS
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 article

SortieArticle : Méthode permettant de diminuer la quantité en stock
EntreeArticle : 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 4
 Le
Le concept
concept de
de classe
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 type
primitives.

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 5
La classe est une définition d’objets ayant le même comportement (méthodes),
la même structure (mêmes propriétés)

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
0021266950863 6
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.
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.

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.

L’instanciation

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

Programmer revient donc à décrire des classes d’objets, à caractériser leur

structure et leur comportement puis à instancier ces classes pour créer des
objets
0021266950863 7
 L'ENCAPSULATION
L'ENCAPSULATION
Le concept d’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.
Le masquage des informations

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),
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 ses 8
0021266950863
traitements appelés aussi méthodes ou services
 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 9
 hhéritage
éritage

Véhicule

N° plaque
Poids total

spécialisation
Généralisation
Camion Voiture Bus
Charge portes capacité

0021266950863 10
Pourquoi hériter ?

1. Pour ré-utiliser un type existant

2. Pour relier des types entre eux
3. Pour réduire la programmation

Comment hériter ?

Par spécialisation

Exprimer qu’un type est un cas particulier d’un autre type

Exemple : un Camion est un Véhicule particulière

Par enrichissement

Ajouter des propriétés et des fonctionnalités à un type objet

0021266950863 11
 Fonctionnement de ll’héritage
’héritage

Un objet hérite des champs et des méthodes de tous ses types ascendants

¾ champs hérités
¾ méthodes héritées

De plus, un objet dispose des champs et des méthodes de son propre type
(nouveaux noms)

¾ champs supplémentaires
¾ méthodes supplémentaires

Dans un type, on peut redéfinir une méthode d’un type ascendant

¾ méthodes redéfinies

0021266950863 12
 Exemple
Exemple

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 publique
de 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 variables
d’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 13
 hhéritage
éritage
Hiérarchie des classes

Personnel
Cin
Nom
anneeNaissance

Enseignant Chercheur

Matière domaineDeRecherches
classeNiveau nombrePublications

0021266950863 14
 la surcharge
¾ On appelle surcharge le fait d’avoir plusieurs méthodes qui ont le

même nom au sein de la même classe

¾ Les exemplaires de la méthode ont des paramètres différents

¾ Ils peuvent avoir le même type de retour

¾ Par contre, impossible d’avoir des types de retour différents pour

les mêmes paramètres

0021266950863 15
 Surcharge : exemple
class Additionneur {

static int somme(int a, int b) // 1

{
return (a+b);
}
static int somme(int a, int b, int c) // 2
{
return (a+b+c);
}
static float somme(float a, float b) // 3
{
return (a+b);
}
static float somme(int a, int b) // interdit à cause de 1
{
return ((float)a+(float)b);
}
}

0021266950863 16
 Polymorphisme

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 17
 Figure

DessineToi()

Cercle Rectangle Triangle Octogone

DessineToi ( ) DessineToi ( ) DessineToi ( ) 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 18
 Rappel
Cet 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 19
 Exemples d'objets

Un objet voiture
uneVoiture

Attributs :
couleur = bleue
poids = 979 kg
puissance = 12 CV
capacité carburant = 50 l
conducteur = Dupont
vitesse instantanée = 50 km/h

Opérations :
démarrer ()
déplacer ()
mettreEssence ()

Un objet fenêtre Un objet compte

uneFenêtre unCompte

Attributs : Attributs :
point-sup-gauche débit
point-inf-droit crédit
texture titulaire
en-tête
Opérations :
Opérations : déposer (somme)
activer () retirer (somme)
fermer () avoirSolde ()
réduire (coeff)
0021266950863 agrandir (coeff) 20
déplacer (lieu)
 Classe
Plusieurs 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
0021266950863 21
• mécanisme d’instanciation).
 Instance
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.

Classe

Instances ...

L'instanciation est le processus par lequel on crée de nouveaux objets

à partir du modèle défini par une classe.
0021266950863 22
 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

Démarrer
Kilométrage
Se déplacer niveau d’essence

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 23
 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 de

la 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 de

l’objet concerné. L’implémentation d’une opération peut évoluer sans modifier l’interface
de 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 interface0021266950863
constitue un contrat entre l’objet et ses clients, c’est-à-dire entre24
le
concepteur et ses utilisateurs.
 Héritage
L'héritage est le mécanisme de transmission des propriétés d'une sur-classe
vers ses sous-classes.

Compte
Compte
crédit
crédit débit
débit
déposer
déposer retirer
retirer avoirSolde
avoirSolde

Compte d'épargne Compte d'épargne

Taux Crédit
calculerIntérêts débit
Taux

déposer
retirer
avoirSolde
calculerIntérêts

¹ L’héritage évite la duplication et facilite la réutilisation.

0021266950863 25
 Constructeur
Méthode spéciale, à mi chemin entre la méthode de classe et la méthode
d'instance chargée de créer un nouvel objet en mémoire et d'initialiser son état.

0021266950863 26
0021266950863 27
 Destructeur

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.

0021266950863 28
 Héritage et visibilit
Héritage visibilitéé

Une classe fille hérite des attributs et méthodes public(Publiques)

et Protected(protégées) de la classe mère, Elle n’hérite pas des

attributs et méthodes private (Privées) La classe mère ne voit que

ce qui est public dans la classe fille.

Un objet d’une classe mère n’hérite pas des attributs et méthodes

de ses classes filles.

0021266950863 29
 La classe Object

La classe Object est la classe mère dont héritent toutes les

autres classes.

Toute classe définie en Java, que ce soit par l’utilisateur ou

dans un package de l’API, hérite de la classe Object

toute classe hérite des méthodes de la classe Object

0021266950863 30
 Les Interfaces (Héritage Multiple)
(Héritage

0021266950863 31
 LL’implémentation
’implémentation

0021266950863 32
 La Visibilit
Visibilitéé
¾ Public
Accessible par toutes les classes de tous les packages.

Protected
Permet l’accès à la ressource par les classes dérivés(ces dernières
peuvent être situées dans un autre package) et toutes du même
package.

¾ Private
Les attributs qui sont définis avec l’attribut private, ne sont pas
accessible à partir d’autres classes ni par les sous-classes.

0021266950863 33
¾ Abstract

¾ Intérêt

0021266950863 34
0021266950863 35
0021266950863 36
0021266950863 37
0021266950863 38
0021266950863 39
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 matricule
Un statut (Cadre, Employé, Agent de maîtrise)
Un service
Un nom
Un salaire.

On peut connaître le salaire d’un Employé par la fonction membre CalculSalaire().

0021266950863 40
 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()

Sal ari e
- m _iM atri cul e : i nt
- m _cStatut : char
- m _sServi ce : Stri ng
- m _sNom : Stri ng
- m _dSalaire : doubl e
+ Calcul Salaire () : doubl e
+ Affichage () : void

0021266950863 41
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 instruction

Exemple :

Salarie salarie = new Salarie( );

0021266950863 42
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 43
}
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 44
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 45
 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 46
}
0021266950863 47
 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

Sal ari e
- m _i M atri cul e : i nt
- m _cStatut : char
- m _sServi ce : String
- m _sNom : String
- m _dSal ai re : doubl e
+ Cal cul Sal ai re () : doubl e
+ Affi chage () : void
+ getIM atricule () : i nt
+ getCStatut () : char
+ getSServi ce () : Stri ng
+ getSNom () : Stri ng
+ getDSal aire () : doubl e
+ setIM atricule (i nt newM _i M atri cul e) : void
+ setCStatut (char newM _cStatut) : void
+ setSServi ce (String newM _sServi ce) : void
+ setSNom (Stri ng newM _sNom ) : void
+ setDSal ai re (doubl e newM _dSalai re) : void
+ SALARIE ()

0021266950863 48
 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.Il
faut

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
0021266950863 49
données membres sont accessibles partout où la classe est accessible.
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 50
 Aide à la Solution :

Voici la gestion de l'encapsulation pour le matricule de la classe salarié

// Les attributs doivent être déclarés private

private int m_iMatricule ;

// Méthodes d'accès aux données membres, par convention portent le même nom que
la 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
0021266950863 51 ave
finalize( )
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 complet
Salarie 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és
Salarie salarie3 = new Salarie(); // Instanciation
salarie3.matricule(3); // affectation du matricule
salarie3.nom("DUPONT"); // affectation du nom
// affichage
// destruction objet salarie3
0021266950863 52
}
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éfaut

public Salarie()
{
m_iMatricule = 0;
m_sNom = "";
m_cStatut = ' ';
m_sService = "";
m_dSalaire = 0;
0021266950863 53
}
 // Constructeur
public 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;
}
//destructeurs
protected void finalize()
{
System.out.println ("destruction de l'objet " +m_sNom);
}
//Fonctions d'affichage
public 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 54
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 55
0021266950863 56
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’affaire
Un 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 CalculSalaire
Salarie
- m_iMatricule : int
Commercial
- m_cStatut : char
<<extend>> - m_dChiffreAffaire : double
- m_sService : String
- m_sNom : String - m_iTauxCommission : int
# m_dSalaire : double + getITauxCommission () : int
+ CalculSalaire () : double + setITauxCommission (int newM_iTauxCommission) : void
+ Affichage () : void + getDChiffreAffaire () : double
+ getIMatricule () : int + setDChiffreAffaire (double newM_dChiffreAffaire) : void
+ getCStatut () : char
+ getSService () : String
+ getSNom () : String
+ getDSalaire () : double
+ setIMatricule (int newM_iMatricule) : void
+ setCStatut (char newM_cStatut) : void
+ setSService (String newM_sService) : void
+ setSNom (String newM_sNom) : void Construire la classe Commercial qui hérite de la classe Salarie
+ 0021266950863
setDSalaire (double newM_dSalaire) : void 57
+ SALARIE ()
Aide à la solution
class Salarie // idem TP 1 Version B
class 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 membres
public int Commission()
{
return m_nCommission;
…
}
// Constructeur par défaut de la classe salarie
super( ) ; // appel au constructeur par défaut de la classe mère
m_nCommission = 0;
…
}
// Constructeur d'initialisation
public Commercial(int nMatricule, … , // rajouter les nouvelle propriétés
{
super( …);
m_nCommission = nCommission;
…
}
// Méthodes de l'objet
public String CalculSalaire( ){ // intégration des commissions
…
}
Classe d’Application:
Prévoir deux salariés et un ou deux commerciaux
Les instancier avec0021266950863
les constructeurs adéquats 58
Les afficher notamment calculSalaire( ) pour mettre en oeuvre le polymorphisme
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 null

public 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 Salarie
super(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 59
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 60
}
0021266950863 61