Vous êtes sur la page 1sur 50

Techniques de programmation

introduction
encapsulation
setter / getter
constructeur
Programmation Objet
(programme BTS SIO : SLAM2)
statique
propriété objet
héritage
surcharge
polymorphisme
les classes
origine
transtypage
package / MVC
persistance
un objet, c’est quoi ?
introduction Comment gérer les différents joueurs ?
encapsulation Informations du joueur : image, pseudo, vie, position
Actions du joueur : se déplacer, tirer, être touché, mourir…
setter / getter
constructeur
Solution 1 (mauvaise) : programmation historique
Créer des variables et modules séparés.
statique
Solution 2 (bonne) : programmation objet
propriété objet
Regrouper les variables et modules qui concernent le joueur dans un même
héritage nouveau « type » qui se nommera Joueur.
surcharge
polymorphisme
les classes
origine
transtypage
package / MVC
persistance
exemples
introduction
classe Liste : classe Joueur : classe Curseur :
encapsulation propriétés : propriétés : méthodes :
String[] element String nom init(String sql)
setter / getter int selectionné int personnage suivant()
constructeur … int vie …
méthodes : …
statique add(String ligne) méthodes :
propriété objet del(int index) déplacer(int sens)
clear() tirer()
héritage … mourir()

surcharge
polymorphisme
les classes
Les propriétés et méthodes sont appelées
origine
transtypage
les membres de la classe
package / MVC
persistance
classe / objet
introduction Une classe est un type complexe.
encapsulation Un objet est une variable dont le type est une classe
setter / getter objet tJoueur[0] :
classe Joueur :
constructeur nom = "Emds"
propriétés :
personnage = 1
statique String nom
vie = 5
int personnage
propriété objet int vie
objet tJoueur[1] :
nom = "Xzof"
méthodes :
héritage personnage = 3
déplacer(int sens)
vie = 12
surcharge tirer()
mourir()
polymorphisme
les classes Créer un objet = instancier une classe
origine Un objet est une instance d'une classe
transtypage
package / MVC Pour utiliser un objet il faut le déclarer puis le créer (certains
langages permettent d'écrire les 2 étapes sur une seule ligne).
persistance
mise en pratique
introduction objet lstPersonne :
classe Liste :
encapsulation Contenu[] = {"Dupont" ; …}
propriétés :
setter / getter String[] contenu

constructeur méthodes :
objet lstVille :
Contenu[] = {"Paris" ; …}
add(String ligne)
statique
del(int index)
propriété objet …
objet lstPays :
héritage Contenu[] = {"France" ; …}
surcharge
A partir de la classe Liste et des 3 objets présentés ci-dessus, écrire
polymorphisme les instructions qui permettent de répondre aux demandes
suivantes :
les classes
a) ajouter "Bernard" à la liste des personnes
origine lstPersonne.add("Bernard")
transtypage b) ajouter "Nice" à la liste des villes
lstVille.add("Nice")
package / MVC c) supprimer le premier élément (d'indice 0) de la liste des pays
persistance lstPays.del(0)
utilisation
introduction Déclaration d'un
classe Joueur : …
tableau d'objets
encapsulation propriétés : int k;
String nom Joueur[] tJoueur;
setter / getter … Création de l'objet
int personnage
constructeur Int vie tJoueur[0] = new Joueur();
méthodes : …
statique déplacer(int sens) tJoueur[0].nom = "Emds";
tirer() … Utilisation
propriété objet tJoueur[0].tirer();
mourir() d'une
héritage … propriété
surcharge Utilisation d'une
polymorphisme méthode

les classes
origine
Emds : 5 Xzof : 12
transtypage
package / MVC Un objet se déclare comme une variable classique.
persistance Mais il faut ensuite créer l'objet pour pouvoir l'utiliser.
mise en pratique
introduction Dans un jeu, une classe Personnage a été créée. Voici en vrac
encapsulation certains membres de cette classe. Pour chaque membre, vous
préciserez si c'est une propriété ou une méthode.
setter / getter
String pseudo // propriété
constructeur deplace(int direction) // méthode
boolean estMort() // méthode
statique int vie // propriété
propriété objet Déclarez et créez un objet de type Personnage, et faites sur cet
objet les opérations suivantes :
héritage
- Initialiser la vie à 10 et le pseudo à "Xzof"
surcharge - le faire déplacer vers la droite (direction 2)
polymorphisme
- mettre sa vie à 0 s'il est mort
Personnage unPersonnage;
les classes unPersonnage = new Personnage();
unPersonnage.vie = 10;
origine unPersonnage.pseudo = "Xzof";
transtypage unPersonnage.deplace(2);
if(unPersonnage.estMort()){
package / MVC unPersonnage.vie = 0;
persistance }
encapsulation
introduction
classe Joueur : Problème : classe Joueur :
encapsulation String nom Il ne faut pas que le privé :
int personnage programme puisse modifier int vie
setter / getter directement la vie ou faire
int vie mourir()
constructeur déplacer(int sens) mourir le joueur. La vie ne public :
tirer() doit être modifiée que String nom
statique lorsque le joueur est touché
mourir() int personnage
propriété objet et le joueur meurt que s'il déplacer(int sens)
n'a plus de vie. tirer()
héritage Solution :
Il faut protéger certains
surcharge
membres pour qu'ils ne
polymorphisme soient pas accessibles de
l'extérieur.
les classes
origine
tJoueur[k].vie = 5;
transtypage …
Encapsulation =
package / MVC tJoueur[k].mourir(); protection de certains membres
persistance
interface d'une classe
introduction
classe Joueur :
encapsulation privé :
tJoueur[0] = new Joueur(); int vie
setter / getter … mourir()
constructeur tJoueur[0].vie = 25; public :
… String nom
statique tJoueur[0].tirer(); int personnage
propriété objet déplacer(int sens)
tirer()
héritage
surcharge Interface de la classe :
partie accessible de
polymorphisme l'extérieur
les classes
origine Le but est de protéger le maximum de membres
transtypage Il est très important de bien réfléchir sur l'encapsulation des
package / MVC membres et de faire les bons choix pour la protection et la stabilité
des objets.
persistance
abstraction
introduction Envoi de message = appel d'une méthode de l'interface
encapsulation L'objet concerné est dit "receveur".
Envoi d'un
setter / getter La méthode va permettre d'agir sur l'objet. "message"
constructeur
statique tJoueur[k].tirer()
propriété objet
héritage classe
surcharge
polymorphisme Interface partie
extérieur message
les classes
de classe cachée
(publique) (privée)
origine
transtypage
niveaux d'abstraction = niveaux d'accès
package / MVC L'extérieur accède à l'interface de la classe qui accède à la partie
persistance cachée.
setter / getter
introduction Traditionnellement, on protège les classe Joueur :
encapsulation propriétés (données) qui ne sont alors privé :
accessibles de l'extérieur que par les int vie
setter / getter
méthodes. mourir()
constructeur Mais ce n'est pas une obligation. String nom
statique int personnage
public :
propriété objet Principe : setNom(String n)
- mettre toutes les propriétés en privé setPerso(int pers)
héritage
String getNom()
surcharge - créer des méthodes, si nécessaire, pour int getPerso()
accéder à ces propriétés : déplacer(int sens)
polymorphisme tirer()
mutateurs (setters) : pour modifier
les classes accesseurs (getters) : pour récupérer
origine
transtypage
package / MVC
Il ne faut créer que les getters et setters nécessaires.
persistance
setter / getter
introduction code du setter de la propriété nom :
public void setNom(String n){
classe Joueur :
encapsulation privé :
nom = n;
setter / getter n est le paramètre int vie
}
mourir()
constructeur String nom
statique int personnage
nom est inconnu dans la public :
propriété objet méthode ? C'est donc une setNom(String n)
propriété de la classe setPerso(int pers)
héritage
String getNom()
surcharge int getPerso()
déplacer(int sens)
polymorphisme tirer()
les classes code du getter de la propriété nom :
origine public String getNom(){
return nom;
transtypage }
package / MVC
persistance
mise en pratique
introduction Imaginons l'objet unJoueur de type Joueur, qui a
encapsulation
été préalablement créé. Dites, pour chaque
instruction, si elle est syntaxiquement correcte :
setterclasse
/ getterJoueur : unJoueur.tirer()
privé : // oui : tirer est public
constructeur
String nom unJoueur.vie = unJoueur.vie + 1
String personnage // non : vie est privé
statique
int vie unJoueur.déplacer()
mourir()
propriété objet // non : déplacer attend un paramètre
public : unJoueur.getVie() = 5
héritage
setNom(String n) // non : getVie n'est pas une propriété
setPerso(int pers)
surcharge unJoueur.estMort()
String getNom() // oui (estMort est public) à condition de l'utiliser
polymorphisme
int getPerso() (dans un test, une affectation ou un retour)
int getVie()
les classes unJoueur.mourir()
déplacer(int sens) // non : mourir est privé
origine
tirer() return unJoueur.getNom()
boolean estMort() // oui getNom est public
transtypage
println(unJoueur.setNom())
package / MVC // non (2 erreurs) : il manque le paramètre, et setNom
persistance ne retourne rien
constructeur
introduction Qu'est-ce qu'un constructeur ?
✓ Membre public non typé classe Joueur :
encapsulation privé :
✓ Porte un nom reconnaissable int vie
setter / getter
(généralement le même nom que mourir()
constructeur la classe) String nom
statique ✓ S'exécute automatiquement au int personnage
public :
moment où l'objet est créé
propriété objet Joueur(String n, int pers)
déplacer(int sens)
héritage
tirer()
Constructeur :
surcharge
public Joueur(String n, int pers){
polymorphisme nom = n;
personnage = pers;
les classes vie = 10;
origine }

transtypage
Le constructeur est souvent utilisé pour valoriser (initialiser) les
package / MVC
propriétés privées.
persistance
constructeur
introduction Lors de la création de l'objet (classe classe Joueur :
encapsulation instanciée), il ne faut pas oublier les privé :
paramètres du constructeur. int vie
setter / getter
mourir()
constructeur String nom
statique int personnage
public :
propriété objet Joueur(String n, int pers)
déplacer(int sens)
héritage
tirer()
surcharge
Joueur[] tJoueur;
polymorphisme

les classes tJoueur[0] = new Joueur("Emds", 1);

origine
transtypage
En l'absence de constructeur, il suffit de ne pas mettre de
package / MVC paramètres lors de l'instanciation.
persistance
destructeur
introduction Qu'est-ce qu'un destructeur ?
✓ Membre public non typé et sans classe Joueur :
encapsulation privé :
paramètre
setter / getter int vie
✓ Porte un nom reconnaissable mourir()
constructeur (généralement le même nom que String nom
statique la classe + un signe spécifique) int personnage
public :
✓ S'exécute automatiquement au
propriété objet Joueur(String n, int pers)
moment où l'objet est libéré ~Joueur()
héritage
déplacer(int sens)
surcharge tirer()

polymorphisme
Destructeur :
les classes public ~Joueur() {
println(nom + "est mort");
origine }
transtypage
package / MVC Le destructeur est en réalité très rarement utilisé.
persistance
mise en pratique
introduction a) Ecrire les méthodes de la
classe Personnage :
encapsulation privé : classe
String pseudo
setter / getter public int getVie(){
int vie
public : return vie;
constructeur
Personnage(String unPseudo, int uneVie) }
statique boolean estMort()
propriété objet int getVie()
String getPseudo()
héritage
public Personnage(String unPseudo, int uneVie){
surcharge
pseudo = unPseudo;
polymorphisme vie = uneVie;
}
les classes
public boolean estMort(){
origine return (vie==0);
transtypage }
String String getPseudo(){
package / MVC return pseudo;
}
persistance
mise en pratique
introduction b) Ecrire la fonction
classe Personnage :
encapsulation privé : creePersonnage qui reçoit
String pseudo en paramètre un pseudo et
setter / getter
int vie qui retourne un objet de
constructeur public : type Personnage créé à
Personnage(String unPseudo, int uneVie) partir de ce pseudo et en
statique boolean estMort()
initialisant la vie à 10.
propriété objet int getVie()
String getPseudo()
héritage
surcharge public Personnage creePersonnage(String pseudo){
Personnage perso;
polymorphisme perso = new Personnage(pseudo, 10);
les classes return perso;
}
origine
// ou (sans passer par un objet intermédiaire)
transtypage
public Personnage creePersonnage(String pseudo){
package / MVC return (new Personnage(pseudo, 10));
}
persistance
mise en pratique
introduction c) Ecrire la fonction etatPersonnage qui reçoit en paramètre un objet
encapsulation de type Personnage et qui retourne :
- si le personnage est vivant, une chaîne du type : "Nicolas : 5" (le 5
setter / getter représente ici la vie restant à Nicolas).
constructeur - si le personnage est mort, une chaîne du type : "Nicolas est mort"
public String etatPersonnage(Personnage perso){
statique if(perso.estMort()){
propriété objet return perso.getPseudo()+" est mort";
}else{
héritage return perso.getPseudo()+" : "+perso.getVie();
}
surcharge
}
polymorphisme
classe Personnage :
privé :
les classes String pseudo
int vie
origine public :
transtypage Personnage(String unPseudo, int uneVie)
boolean estMort()
package / MVC int getVie()
persistance String getPseudo()
membre statique
introduction
Problème : classe Joueur :
encapsulation Chaque joueur possède des informations privé :
personnelles (nom, personnage, vie) mais int vie
setter / getter la valeur de la vie au départ est la même mourir()
constructeur pour tous les joueurs. String nom
Solution : int personnage
statique Utiliser une propriété qui aura la même int static maxvie
propriété objet valeur pour tous les joueurs. public :
Joueur(String n, int pers)
héritage
static int getMaxvie()
surcharge Exemple d'utilisation : static setMaxvie(int mv)
Joueur.setMaxvie(10) déplacer(int sens)
polymorphisme tirer()
les classes
origine Membre statique = membre à portée de classe
transtypage
package / MVC Le membre statique n'est pas attaché à une instance.
persistance Il est donc directement accessible par le nom de la classe.
propriété "objet"
introduction
Problème : classe Joueur :
encapsulation Chaque joueur possède une boule qu'il privé :
peut lancer quand il veut. La boule int vie
setter / getter possède des caractéristiques. mourir()
constructeur Solution : String nom
Ajouter une propriété dont le type est int personnage
statique une autre classe. Boule boule
propriété objet public :
// dans la classe Joueur Joueur(String n, int pers)
héritage public Boule getBoule(){ Boule getBoule()
surcharge return boule; déplacer(int sens)
} tirer()
polymorphisme // dans la classe Boule classe Boule :
les classes public Joueur lance(){ privé :
Joueur victime; …
origine victime = …; public :
return victime; Boule()
transtypage
} Joueur lance()
package / MVC // exemple d'appel à l'extérieur de la classe
Joueur blessé = joueur.getBoule().lance();
persistance
référence d'un objet
introduction Joueur joueur1, joueur2, joueur3;
String nom1, nom2, nom3;
encapsulation

setter / getter joueur1 = new Joueur("Emds", 1); // un nouvel objet est créé
joueur2 = joueur1; // joueur2 fait référence à joueur1 (adresse)
constructeur joueur3 = joueur1.clone(); // joueur3 est une copie de joueur1
statique joueur2.setNom("Xzof"); // joueur2 change de nom
joueur3.setNom("Monster"); // joueur3 change de nom
propriété objet nom1 = joueur1.getNom(); // nom1 = "Xzof" !!!
héritage nom2 = joueur2.getNom(); // nom2 = "Xzof"
nom3 = joueur3.getNom(); // nom3 = "Monster"
surcharge
polymorphisme Il n'y a que le "new" et le clonage pour créer un nouvel objet à une
adresse différente.
les classes
Une affectation ne fait que transférer l'adresse (la référence) de
origine l'objet.
transtypage x != x.clone() // comparaison des adresses
x.equals(x.clone()) // comparaison des contenus
package / MVC
x.getClass() == x.clone().getClass() // mêmes classes
persistance
classe mère
classe de base
héritage simple
introduction sur-classe
Problème : classe Arme :
encapsulation Imaginons que les joueurs puissent aussi privé :
manipuler des armes. String nom
setter / getter Il existe 2 types d'armes : les longues portées int puissanceMax
constructeur qui peuvent tirer et les courtes portées qui public :
peuvent frapper. Arme(…)
statique Solution : ranger()
propriété objet Créer 2 sous classes d'armes qui auront leurs
propres caractéristiques. héritage
héritage dérivation
surcharge
classe ArmeCourte
hérite de Arme : classe ArmeLongue
polymorphisme public : hérite de Arme :
les classes frapper(int puissance) privé :
classe fille int distanceMax
origine
classe dérivée public :
transtypage sous-classe tirer(int distance, int puissance)
package / MVC Les classes filles héritent des membres de la classe mère (excepté
persistance les membres privés).
héritage et protection
introduction Problème :
Certains membres privés de la classe mère doivent être accessibles par les
encapsulation
classes filles.
setter / getter 2 solutions (une mauvaise et une bonne) :
- Laisser les membres "privés" et ajouter les getters et setters.
constructeur - Mettre ces membres en "protégés" (nouveau niveau de protection).
statique
classe Arme :
propriété objet privé :
héritage String nom classe Arme : classe Arme :
int puissanceMax privé : protégé :
surcharge public : String nom String nom
polymorphisme Arme(…) int puissancemax int puissanceMax
ranger() public : public :
les classes Arme(…) Arme(…)
origine String getNom() ranger()
int getPuissanceMax()
transtypage ranger()
package / MVC
Il existe donc 3 niveaux de protection des données :
persistance privé ou protégé ou public
utiliser l'héritage
introduction classe ArmeCourte
encapsulation hérite de Arme : classe Arme :
public : privé :
setter / getter String nom
frapper(int puissance)
protégé :
constructeur
classe ArmeLongue int puissanceMax
statique public :
hérite de Arme : Arme(…)
propriété objet privé : ranger()
int distanceMax
héritage
public :
surcharge tirer(int distance, int puissance)
oui (privé mais on
est dans la classe)
polymorphisme
public void tirer(int distance, int puissance){
oui (protégé dans la
les classes if(distance <= distanceMax){ classe mère)
if(puissance <= puissanceMax){
origine println("arme "+nom+" utilisée");
transtypage …
} non (privé dans la
package / MVC } classe mère)
persistance }
utiliser l'héritage
introduction classe ArmeCourte
encapsulation hérite de Arme : classe Arme :
public : privé :
setter / getter String nom
frapper(int puissance)
protégé :
constructeur
classe ArmeLongue int puissanceMax
statique public :
hérite de Arme : Arme(…)
propriété objet privé : ranger()
int distanceMax
héritage
public :
surcharge tirer(int distance, int puissance)
polymorphisme Imaginons que la classe Joueur possède la propriété arme de type
Arme et un getter sur cette propriété. oui (ranger est
les classes public dans Arme)
origine
tJoueur[k].getArme().ranger();
transtypage println(tJoueur[k].getArme().puissanceMax);

package / MVC tJoueur[k].getArme().frapper(150); non (mais on saura
persistance bientôt faire !)
héritage multiple
introduction
classe Liquide : classe Alimentation :
encapsulation int volume Date dateFabrication
… …
setter / getter
constructeur
statique classe Vin hérite
propriété objet de Liquide et classe fille
qui hérite de
héritage
Alimentation : plusieurs
String cépage classes
surcharge …
polymorphisme
Ne jamais utiliser l'héritage multiple :
les classes - Provoque des conflits au niveau des héritages
origine - Va à l'encontre de la programmation propre et optimisée

transtypage
package / MVC L'héritage multiple est possible en C++, mais abandonné en Java car
considéré comme trop dangereux.
persistance
mise en pratique
introduction Imaginons 3 objets préalablement classe Personnage :
encapsulation créés : unPerso de type Personnage, privé :
unMortel de type Mortel, String pseudo
setter / getter protégé :
unImmortel de type Immortel.
constructeur Dites, pour chaque instruction, si elle estTouché()
est syntaxiquement correcte : public :
statique Personnage(String unPseudo)
deplace(int direction)
propriété objet
String getPseudo()
héritage setPseudo(String unPseudo)
attaque()
surcharge
polymorphisme classe Mortel hérite de
les classes
classe Immortel hérite de Personnage :
Personnage : privé :
origine privé :
int vie
String pouvoir
transtypage public :
public : Mortel(String unPseudo, int uneVie)
package Immortel(String
/ MVC unPseudo, String unPouvoir) boolean estMort()
String getPouvoir()
persistance int getVie()
unMortel.deplace(2);
// oui (deplace est public dans la mère) mise en pratique
println(unMortel.getVie());
introduction
// oui (getVie est directement dans la classe) classe Personnage :
println(unImmortel.getVie()); privé :
encapsulation
// non (getVie n'est pas dans la classe ni dans la mère) String pseudo
println(unImmortel.pouvoir);
setter / getter protégé :
// non (pouvoir est privé) estTouché()
constructeur
unMortel.estTouché(); public :
// non (protégé n'est pas accessible à partir d'un objet)
statique Personnage(String unPseudo)
unPerso.estTouché(); deplace(int direction)
propriété objet n'est pas accessible à partir d'un objet)
// non (protégé String getPseudo()
println(unPerso.pseudo);
héritage setPseudo(String unPseudo)
// non (pseudo est privé) attaque()
surcharge
println(unPerso.getVie());
// non (la mère n'accède pas aux filles)
polymorphisme classe Mortel hérite de
classe Immortel hérite de
les classes Personnage :
Personnage : privé :
origine privé :
int vie
String pouvoir
transtypage public :
public : Mortel(String unPseudo, int uneVie)
package Immortel(String
/ MVC unPseudo, String unPouvoir) boolean estMort()
String getPouvoir()
persistance int getVie()
notion de surcharge
introduction
Problème : classe Arme :
encapsulation On veut pouvoir créer une arme de 2 privé :
façons différentes : String nom
setter / getter - soit en initialisant le nom et la puissance protégé :
constructeur - soit sans initialisation (en prévoyant int puissanceMax
d'initialiser les propriétés plus tard en public :
statique utilisant des "setters"). Arme(String n, int p)
propriété objet Solution : Arme()
Créer 2 méthodes de même nom (ici, des ranger()
héritage constructeurs) mais de signatures setNom(String nom)
différentes. setPuissance(int pMax)
surcharge

polymorphisme
les classes
origine
Méthode surchargée = méthode possédant
transtypage le même nom qu'une autre méthode
package / MVC avec une signature différente
persistance
polymorphisme (surcharge)
introduction
Problème : classe Arme :
encapsulation On veut uniformiser l’utilisation d’une privé :
arme courte ou longue : méthode String nom
setter / getter utiliser() au lieu de frapper() ou tirer(). protégé :
constructeur Solution : int puissanceMax
Créer des méthodes de même nom et de public :
statique signature différente. Arme(String n, int p)
propriété objet Arme()
utiliser(int p)
héritage

surcharge
Polymorphisme statique
polymorphisme
de surcharge
les classes
(overloading) :
- méthodes de même nom dans 2
origine classes différentes ou dans la classe ArmeLongue :
même privé :
transtypage
int distanceMax
- signatures différentes
package / MVC public :
utiliser(int p, int d)
persistance
polymorphisme (redéfinition)
introduction
Problème : classe Arme :
encapsulation Ranger une "arme longue" nécessite les privé :
mêmes traitements que pour toutes les String nom
setter / getter armes plus certains traitements particuliers. protégé :
constructeur Solution : int puissanceMax
Créer 2 méthodes de même nom (et de public :
statique même signature) mais une dans la classe Arme(String n, int p)
propriété objet mère et l'autre dans la classe fille. Arme()
utiliser(int p)
héritage
ranger()
surcharge
Polymorphisme dynamique …

polymorphisme
d'héritage
les classes
(overriding) :
- méthodes de même nom et de classe ArmeLongue :
origine même signature privé :
transtypage - 2 classes différentes d'une même int distanceMax
hiérarchie (mère et fille) public :
package / MVC
utiliser(int p, int d)
persistance ranger()
polymorphisme
introduction Polymorphisme = classe Arme :
encapsulation faculté de prendre plusieurs privé :
String nom
setter / getter formes protégé :
constructeur int puissanceMax
Problème :
statique Si les méthodes ont le même nom, public :
comment le programme sait laquelle il doit Arme(String n, int p)
propriété objet exécuter lors d'un appel ? Arme()
Solutions : utiliser(int p)
héritage
1er cas : méthodes de même nom avec ranger()
surcharge signatures différentes …

polymorphisme → Reconnaissance par la signature


2ème cas : même nom même signature
les classes → La méthode de la classe est appelée en
origine
priorité classe ArmeLongue :
→ Pour forcer l'appel de la méthode de la privé :
transtypage classe mère : faire précéder de "super." int distanceMax
→ Pour forcer l'accès aux membres de la public :
package / MVC classe actuelle : faire précéder de "this." utiliser(int p, int d)
persistance ranger()
this / super
introduction // classe Arme
public Arme(String nom, int puissanceMax){
encapsulation this.nom=nom;
this.puissanceMax=puissanceMax;
classe Arme :
setter / getter privé :
}
constructeur "this" String nom
obligatoire protégé :
statique Int puissanceMax
// classe ArmeLongue
propriété objet public :
public void utiliser(int p, int d){
Arme(String nom,
super.utiliser(p);
héritage int puissanceMax)

"super" Arme()
surcharge this.ranger();
optionnel utiliser(int p)
}
polymorphisme "this" ranger()
optionnel
les classes
// classe ArmeLongue classe ArmeLongue :
origine public void ranger(){ privé :
transtypage super.ranger(); int distanceMax
… public :
package / MVC } "super"
obligatoire utiliser(int p, int d)
persistance ranger()
classe métier
introduction Dans un programme, il est nécessaire de manipuler des objets du monde
réel (joueurs, armes…).
encapsulation
setter / getter
constructeur
Classe métier =
classe qui contient des propriétés et classe Joueur :
statique …
des méthodes pour décrire un objet
propriété objet qui a une vie propre (personne,
héritage lieu, chose…)
surcharge et qui serait susceptible d'être classe Arme :
mémorisé (par exemple dans une …
polymorphisme
base de données)
les classes
origine classe ArmeCourte :

transtypage
package / MVC L'écriture des classes métiers est sous classe ArmeLongue :
la responsabilité du programmeur. …
persistance
classe technique
introduction Il est parfois utile d'avoir des outils pour manipuler des objets de types
spécifiques, par exemple des dates (calculer le nombre de jours entre 2
encapsulation
dates…)
setter / getter classe Date :
privé :
constructeur Classe technique = …
statique Classe "boite à outils" pour public :
Date()
propriété objet
gérer des types techniques Date(String uneDate)
(dates, chaines, curseurs, int getJour()
héritage
collections…) int getMois()
surcharge int getAnnee()
int nbJours(Date uneDate)
polymorphisme …
date1 = new Date("05/12/2015");
les classes
date2 = new Date("03/01/2016");
origine difference = date1.nbJours(date2):
// calcule le nombre de jours entre les 2 dates
transtypage
package / MVC
Quasiment tous les langages offrent des classes techniques
persistance prédéfinies, mais le programmeur peut aussi en créer.
classe générique
introduction Le but est de permettre de choisir le type au moment de la déclaration de
l'objet.
encapsulation
C'est bien sur primordial pour une Collection d’objets (un outil qui va
setter / getter remplacer les tableaux et qui permet de gérer un ensemble d’objets).

constructeur classe Collection <type> :


statique
Classe générique = privé :
Classe qui manipule au …
type
propriété objet public :
moins un type non défini à variant
héritage Collection <type>()
l'avance, paramétrable au int cardinal()
surcharge moment de la déclaration add(<type> element)
de l'objet. del(int k)
polymorphisme
int index(<type> element)
les classes <type> get(int k)

origine
Collection<Joueur> lesJoueurs;
transtypage
lesJoueurs = new Collection<Joueur>()
package / MVC
type précisé au
persistance moment de la création
collection
introduction Je veux ajouter un
int k; joueur à la collection classe Joueur :
encapsulation Joueur joueur; privé :
Collection<Joueur> col; …
setter / getter
col = new Collection<Joueur>(); public :
constructeur joueur = newJoueur("Emds",
Joueur("Emds",1)); 1); Joueur(String nom,
col.add(new int vie)
statique col.add(joueur);
… tirer()
propriété objet col .get(k) .tirer(); …
… Et si on l'écrivait en
héritage
une seule ligne ? classe Collection <type> :
surcharge privé :

polymorphisme Je veux que le
public :
kème joueur tire
les classes Collection <type>()
int cardinal()
origine add(<type> element)
transtypage del(int k)
Il existe beaucoup de variantes int index(<type> element)
package / MVC <type> get(int k)
aux collections, comme les
persistance dictionnaires… …
abstraite
classe
introduction Une arme est obligatoirement "ArmeCourte" ou "ArmeLongue".
abstraite
Il doit être interdit de créer un objet juste de type "Arme".
encapsulation
setter / getter Classe abstraite = Classe abstraite Arme :
classe qui ne peut être protégé :
constructeur
String nom
statique
instanciée int puissancemax

propriété objet
Méthode abstraite = public :
utiliser(int puissance)
Méthode vide qui doit être …
héritage
redéfinie dans toutes les abstract desactiver()
surcharge classes filles Méthode
polymorphisme vide

les classes Classe ArmeLongue :


classe privé :
origine concrète int distancemax
transtypage
Classe ArmeCourte : public :
public : ArmeLongue()
méthode
package / MVC ArmeCourte() utiliser(int p, int d)
obligatoirement
desactiver() desactiver()
redéfinie
persistance
collection d'armes abstraite
(mais uniquement
introduction ArmeCourte ou
int k; ArmeLongue)
encapsulation
Collection<Arme> lesArmes;
lesArmes
setter / getter = new Collection<Arme>(): Classe abstraite Arme :
lesArmes.add(new ArmeCourte()); protégé :
constructeur
lesArmes.add(new ArmeLongue()); String nom

statique int puissancemax
for(int k=0;k<lesArmes.cardinal();k++){ public :
propriété objet
lesArmes.get(k).desactiver(); utiliser(int puissance)
}
héritage …
… abstract desactiver()
surcharge
polymorphisme La bonne
méthode sera Classe ArmeLongue :
les classesautomatiquement
privé :
origine appelée !
int distancemax
transtypage
Classe ArmeCourte : public :
public : ArmeLongue()
package / MVC ArmeCourte() utiliser(int p, int d)
desactiver() desactiver()
persistance
finale
introduction Classe finale = ne peut être héritée
encapsulation Méthode finale = ne peut être redéfinie
setter / getter Propriété finale = ne peut être modifiée (constante)
constructeur ne peut être héritée
statique (pas de classe fille)

propriété objet
Classe finale ArmeLongue :
héritage privé :
surcharge final int distancemax = 100
Ne peut être public :
polymorphisme modifiée (constante) utiliser(int puissance)
les classes …
final ranger()
origine
transtypage ne peut être
package / MVC redéfinie

persistance
interface (classe)
introduction Interface =
encapsulation classe abstraite dont toutes les propriétés sont des
setter / getter constantes de classes (constante, ou static/final),
constructeur
toutes les méthodes sont abstraites
et tous les membres sont publics.
statique
propriété objet Une classe peut implémenter plusieurs interfaces qui elles-mêmes
héritage peuvent hériter de plusieurs autres interfaces.

surcharge 1 classe mère


possible maximum
polymorphisme
Syntaxe Java :
les classes public class nomClasse extends nomClasseMère
origine implements nomInterface1, nomInterface2 {…}

transtypage
package / MVC plusieurs interfaces
possibles
persistance
interface (classe)
introduction
Un interface peut servir à : formater des classes
encapsulation
Interface Forme : Classe Carré Classe Rond
setter / getter impl. Forme :
public : impl. Forme :
constructeur float surface() privé : privé :
float périmètre() float côté float rayon
statique public : public :
propriété objet Carré(float côté) Rond(float rayon)
inutile de préciser float surface() float surface()
héritage "abstraite" float périmètre() float périmètre()
… …
surcharge
// classe Carré
polymorphisme collection<Forme> formes;
public float périmètre(){ formes.add(new Carre(5));
les classes
return (4*côté); formes.add(new Rond(2));
} …
origine
for(int k=0;k<formes.cardinal();k++){
transtypage
// classe Rond println(formes.get(k).périmètre());
public float périmètre(){ }
package / MVC
return (2*Math.pi()*rayon);
}
persistance
interface (classe)
introduction Un interface peut servir à :
encapsulation stocker les constantes globales de l'application
setter / getter
constructeur Interface Globale : Classe Controle
statique
public : implemente Globale :
static final PORT = 6666 public :
propriété objet static final CHEMIN = "media/" evenementEntreeJeu(String info)
… …
héritage
surcharge
// classe Controle
polymorphisme public void evenementEntreeJeu(String info){
if(info.equals("serveur")){
les classes new ServeurSocket(this, PORT);
origine }

transtypage }
package / MVC la constante PORT est
directement reconnue
persistance
origine d'un objet
introduction Il est parfois bien pratique de connaître le "type" d'un objet (de quelle
classe il est l'instance).
encapsulation
C'est particulièrement utile pour les objets qui sont des instances de
setter / getter classes filles.
constructeur Origine d'un objet =
statique Classe dont l'objet est l'instance (type de l'objet)
propriété objet collection<Arme> lesArmes;…
héritage lesArmes.add(new ArmeCourte());
lesArmes.add(new ArmeLongue());
surcharge …
// compter le nombre d'armes courtes
polymorphisme
int nbArmesCourtes = 0;
les classes for(int k=0;k<lesArmes.cardinal();k++){
arme = lesArmes.get(k);
origine if(arme instanceof ArmeCourte){
transtypage nbArmesCourtes++;
}
package / MVC }
persistance println(nbArmesCourtes);
casting (transtypage)
introduction Il est parfois utile de changer le type d'un objet car le type n'est pas
toujours connu au moment de l'utilisation.
encapsulation
setter / getter caster un objet = transtyper un objet =
constructeur changer le type de l'objet (si c'est possible)
statique Objet1 = (nouvelleClasse)objet2;
propriété objet
Le casting n'est possible que sur des objets compatibles (donc
héritage
faisant partie de la même hiérarchie de classes).
surcharge frapper() n'existe pas
polymorphisme dans la classe Arme
for(int k=0;k<lesArmes.cardinal();k++){
les classes if(lesArmes.get(k) instanceof ArmeCourte){
lesArmes.get(k).frapper(150);
origine ((ArmeCourte)lesArmes.get(k)).frapper(150);
transtypage }
lesArmes.get(k).desactiver();
desactiver() existe dans la
package / MVC } classe Arme et est redéfinie
persistance dans les classes filles
bibliothèque / package
introduction bibliothèque (package) =
encapsulation regroupement de classes
setter / getter (+ éventuellement d'autres bibliothèques)
constructeur
Organisation :
statique
les classes sont regroupées par thème
propriété objet
Réutilisation :
héritage les bibliothèques sont réutilisables dans plusieurs applications
surcharge Partage :
polymorphisme les bibliothèques peuvent être partagées entre développeurs
les classes // en C++
origine include "nomBiblio.h" ;
// en C#
Il existe des bibliothèques
transtypage using nomBibio ; standards.
// en Java Ce pendant le programmeur
package / MVC
import nomPackage.* ; peut créer les siennes.
persistance
le M.V.C.
introduction MVC =
encapsulation Modèle Vue Contrôleur (Model View Controler)
setter / getter
Il permet d'organiser les classes et packages de l'application en 3
constructeur packages ayant chacun un rôle précis.
statique Le programme est propre et les interactions sont maîtrisées.
propriété objet
contrôleur Changer l'affichage n'a
héritage pas d'incidence sur les
contient les classes données (le modèle)
surcharge
qui permettent de
polymorphisme faire le lien entre le
modèle
les classes modèle et la vue vue

origine contient les classes


contient les classes
d’affichage
transtypagemétiers
Changer la gestion des (ChoixJoueur,
(Joueur,
package / MVC Boule...) données n'a pas d'incidence Arene...)
sur les interfaces (la vue)
persistance
persistance
introduction Problème :
Les objets sont des variables, donc avec une durée de vie limitée.
encapsulation
Le but serait de pouvoir "sauver" les objets métiers pour les "réutiliser".
setter / getter
constructeur Solution 1 : sérialiser les objets
statique
mémorisation dans un fichier binaire
(facile, léger mais local et pas de SQL possible)
propriété objet
Solution 2 : sauver au format XML
héritage
mémorisation dans un fichier de données XML
surcharge (facile car outils existants, léger car texte, portable car
polymorphisme standard mais pas de SQL possible)
les classes Solution 3 : enregistrer dans une base de
origine données
transtypage (portable et SQL possible)
package / MVC
→ avec curseur (la sauvegarde doit être bien gérée)
→ avec mapping (lien direct entre objet et BD)
persistance
quoi d'autre ?
introduction A travers ce cours, vous n'avez vu que les bases de la
encapsulation programmation objet.
setter / getter
constructeur
Les notions abordées sont cependant fondamentales et
doivent être parfaitement assimilées pour passer à la
statique
suite. Pour cela, il faut pratiquer.
propriété objet
héritage Le monde de la programmation objet est très vaste.
surcharge
polymorphisme Vous découvrirez aussi :
les classes
- Les Frameworks
- Les design patterns (singletons, fabriques…)
origine
- Les tests unitaires
transtypage - …
package / MVC
persistance

Vous aimerez peut-être aussi