SI4 – LES BASES DE LA PROGRAMMATION Algorithmique et

BTS SIO
SI4 – LES BASES DE LA PROGRAMMATION
Algorithmique et Python
Lycée des Métiers Jacques Prévert
Combs – la – Ville
Section BTS Services Informatiques aux Organisations
1
Analyser et utiliser un programme de gestion de compte bancaire à l’aide de la Programmation Orientée
Objet (POO).
En programmation objet, on répartit les instructions dans des classes représentant les acteurs de la réalité
que le programme se doit d’affronter.
Les classes sont donc les principaux outils de la POO.
Ce type de programmation permet de structurer les logiciels complexes en les organisant comme des
ensembles d’objets qui interagissent entre eux et avec le monde extérieur.
Ainsi, une application bancaire reprendra comme classes, les clients, les comptes en banque, les
opérations bancaires, les emprunts…
Une classe se définit par ses attributs, qui décrivent ce qu’elle est, et ses méthodes, qui décrivent ce
qu’elle fait.
Exemple en Python d’une classe Client (remarque : un nom de classe commence toujours par une
majuscule).
class Client:
def __init__(self,nomInit,prenomInit,adresseInit,ageInit):
self.__nom=nomInit
self.__prenom=prenomInit
self.__age=ageInit
self.__adresse=adresseInit
def donneNom(self):
return self.__nom
def donneAdresse(self):
return self.__adresse
def donneAge(self):
return "age: " + str(self.__age)
def __str__(self):
return "client: " + self.__prenom + " " + self.__nom

BTS SIO
SI4 – LES BASES DE LA PROGRAMMATION
Algorithmique et Python
Lycée des Métiers Jacques Prévert
Combs – la – Ville
Section BTS Services Informatiques aux Organisations
2
On utilise un langage de modélisation graphique des développements logiciels dans les projets
informatiques, que l’on nomme UML (Unified Modeling Language).
Sans rentrer dans un cours d’UML complet, inutile à ce niveau, on va toutefois modéliser les classes par
des diagrammes, qui permettent d’identifier facilement les structures des classes d’un système (propriétés
et méthodes dans un premier temps).
Diagramme de Classe Client :
Une classe est représentée en utilisant un rectangle divisé en 3 sections. La section supérieure est le nom
de la classe. La section centrale définit les propriétés (attributs) et celle du bas, les méthodes.
Client
-nom
-prenom
-age
-adresse
+__init()__
+donneNom()
+donneAdresse()
+donneAge()
La visibilité indique qui peut avoir accès aux attributs: le signe - signifie que l’attribut a un accès privé.
Ceci est lié au principe fondamental d’encapsulation en POO qui consiste à protéger l’information contenue
dans un objet et de ne proposer que des méthodes de manipulation.
Le signe + indique donc que la méthode est publique et manipulable par l’utilisateur.
Pour qu’un attribut privé soit récupérable, il faut utiliser un getter (accesseur) ; pour qu’il soit modifiable, il
faut utiliser un setter (mutateur).
Détails de la classe Client :
- La classe Client possède 4 attributs privés inaccessibles de l’extérieur de la classe.
C’est la présence de __ (double tiret bas) qui donne ce caractère privé.
- __init__ est le constructeur de la classe, qui permet d’initialiser les attributs privés.
- La méthode __str__ est héritée de la super-classe object et redéfinie dans cette classe Client.
- 3 méthodes publiques permettent d’accéder aux attributs privés.
- Le mot-clé self est indispensable dès qu’il s’agit de faire référence à l’objet lui-même. De fait,
toutes les méthodes portant sur l’objet se doivent de recevoir ce dernier, c’est-à-dire self en
paramètre (voir utilisation de la classe).

BTS SIO
SI4 – LES BASES DE LA PROGRAMMATION
Algorithmique et Python
Lycée des Métiers Jacques Prévert
Combs – la – Ville
Section BTS Services Informatiques aux Organisations
3
Utilisation de la classe Client :
Exemple de programme :
#création d’un premier client (d’un objet de type classe Client)
client1 = Client(‘Bersini’, ‘Hugues’, ‘rue Louise’, 20)
#création d’un deuxième client (d’un objet de type classe Client)
client2 = Client(‘Lendersi’, ‘Pascale’, ‘rue Juliette’, 30)
Ici, les 2 clients sont créés grâce au constructeur __init__ qui possède 4 paramètres. Lors de la création, il
faut donc écrire 4 arguments.
Donc, l’instruction client3 =Client() déclenchera l’exception
TypeError: __init__() missing 4 required positional arguments: 'nomInit', 'prenomInit', 'adresseInit', and
'ageInit'
Les instructions:
print(client1)
print(client2)
permettent d’exécuter implicitement la méthode __str__() et d’afficher le nom et le prénom des clients
créés :
client: Hugues Bersini
client: Pascale Lendersi
Pour connaître l’adresse du client1, il faut entrer :
print(client1.donneAdresse()) résultat rue Louise
La méthode donneAdresse(self) retourne la bonne adresse. Le mot-clé self correspond au client1.
Cette méthode est un accesseur.
Le client1 déménage ; son adresse change. On pourrait recréer complètement le client comme
précédemment mais ce n’est pas l’idéal. On va donc rajouter une méthode dans la classe, qui va agir sur
l’attribut du client créé (mutateur).
def demenage(self, newAdresse) :
self.__adresse =newAdresse
et dans le programme d’utilisation :
client1.demenage(‘rue Juliette’)
print(client1.donneAdresse()) resultat rue Juliette
Le client1 vieillit : procéder de la même façon pour modifier son attribut age.

BTS SIO
SI4 – LES BASES DE LA PROGRAMMATION
Algorithmique et Python
Lycée des Métiers Jacques Prévert
Combs – la – Ville
Section BTS Services Informatiques aux Organisations
4
Association entre classes:
La pratique de l’orienté objet consiste d’abord et avant tout en l’éclatement de l’application logicielle entre
les classes constitutives du projet.
Ainsi, si dans un logiciel bancaire, le client veut retirer 100€ de son compte, c’est l’objet client qui sollicitera
la méthode retire(100) exécutée sur le compte en question.
Ce déclenchement de cette méthode retire(100) sur le compte, provoqué par le client, est appelé un envoi
de message.
On y retrouve en effet, l’expéditeur client, le destinataire compte en banque et le contenu du message
retire(100).
Une association est une relation générique (hiérarchique) entre 2 classes. Elle peut être modélisée en UML
par une ligne reliant les 2 classes. Cette ligne peut être qualifiée avec le type de relation et peut également
comporter des règles de multiplicité (par exemple un à un, un à plusieurs, plusieurs à plusieurs) pour la
relation.
Signification :
Chaque objet client est associé à un ensemble d’objets compteEnBanque et en retour, chaque objet
compteEnBanque est associé à un et un seul client.
Les attributs soulignés sont des attributs statiques associés à la classe plutôt qu’aux objets. On les appelle
des variables de classe.
Ils n’ont besoin que de la classe pour exister et être utilisés. Ils le sont d’ailleurs en faisant toujours allusion
à leur classe (comme dans CompteEnBanque.nombreComptes). Leur utilisation ne nécessite pas de
recourir au mot-clé self. Tout ce qui est statique peut exister sans objet.
CompteEnBanque
-solde
-numero
-modele
-nombreComptes
-nomTitulaire:Client
+__init()__
+retire(entrée montant:int)
+depose(entrée montant:int)
Client
-mesComptes : CompteEnBanque
-nom
-prenom
-age
-adresse
+__init()__
+donneNom()
+donneAdresse()
+donneAge()
+ajoutCompte(entrée nouveauCompte:CompteEnBanque)
+retire()
+depose()
1
1...n

BTS SIO
SI4 – LES BASES DE LA PROGRAMMATION
Algorithmique et Python
Lycée des Métiers Jacques Prévert
Combs – la – Ville
Section BTS Services Informatiques aux Organisations
5
class Client:
def __init__(self,nomInit,prenomInit,adresseInit,ageInit):
self.__nom=nomInit
self.__prenom=prenomInit
self.__adresse=adresseInit
self.__age=ageInit
self.__mesComptes=[]
def donneNom(self):
return self.__nom
def donneAdresse(self):
return self.__adresse
def donneAge(self):
return self.__age
def demenage(self, newAdresse):
self.__adresse =newAdresse
def __str__(self):
return "client: "+ self.__prenom + " " + self.__nom
def retire(self):
c=self.identifieCompte()
print('quel montant?')
x =int(input('?'))
c.retire(x)
def depose(self):
c=self.identifieCompte()
print('quel montant?')
x =int(input('?'))
c.depose(x)
def identifieCompte(self):
print('Sur quel compte?')
x=input('?')
for c in self.__mesComptes:
if c.donneNumero() == x:
res=c
break
return c
def ajouteCompte(self):
self.__mesComptes.append(compte)
compte.assigneTitulaire(self)