Types dérivés

et
programmation OO
Fortran 90
 La notion de classe

Le premier concept fondamental de l’orienté objet est la classe.

Une classe est une structure abstraite qui décrit des objets du
monde réel sous deux angles : ses propriétés (ses
caractéristiques) et ses méthodes (les actions qu’elle peut
effectuer ou son comportement).
 Classe: exemple
La classe Vehicule représente un véhicule, couleur , poids, sont
les propriétés et accélérer/freiner sont deux de ses méthodes.
 La notion d’objet
Les objets sont construits à partir de la classe, par un
processus appelé instanciation. De ce fait, tout objet est une
instance de classe..

La classe est finalement une sorte de moule. Toutes les

instances de classe s’appellent des objets
 Caractéristiques d’un objet
• L’identité : l’identité doit permettre d’identifier sans
ambiguïté l’objet (référence ou nom)
• Les attributs: chaque objet a une valeur par défaut
(lorsqu’elle est indiqué à l’instanciation) pour chacune de
ses propriétés.
• Les méthodes :  chaque objet est capable d’exécuter les
actions ou le comportement défini dans la classe. Ces
actions sont traduites en POO concrètement sous forme
de méthodes. Les actions possibles sur un objet sont
déclenchées par des appels de ces méthodes ou par des
messages envoyées par d’autres objets.
Caractéristiques d’un objet
 Notion d’abstraction

Elle consiste à masquer à l’utilisateur les détails inutiles. Ce

dernier peu ainsi implémenter sa propre logique davantage
complexe sans pour autant avoir à prendre en compte la
complexité cachée et sous-jacente.
 Héritage

Cela signifie qu’une classe B hérite de la classe A. Autrement

dit, la classe B hérite des attributs et méthodes de la classe A.
On peut alors appeler Les méthodes contenues dans la classe A
par la classe B dès lors qu’une instance de la classe B est créée.
Cela fait énormément gagner en temps.
Héritage
 Encapsulation
Il s’agit de regrouper des données avec un ensemble de
routines visant à les lire ou les manipuler. Chaque classe  définit
des méthodes ou propriétés afin d’interagir avec les données.
C’est à partir de la classe que seront créés les différents objets.
Quand un des objets de la classe sera intégré dans le
programme, on parlera de cet objet en tant qu’instance de la
classe : l’objet est créé avec les propriétés de sa classe.
 Encapsulation 2

L’encapsulation est comme un mécanisme de boîte noire qui

empêche l’utilisateur d’utiliser un objet au delà des méthodes
(accesseurs et mutateurs) qui lui sont proposées.
 Encapsulation 3

L’encapsulation permet de définir des niveaux de visibilité des

éléments de la classe. (la portée ou encore le périmètre) Il
existe trois niveaux de visibilité :
• Publique (+): les attributs publics sont accessibles à tous
• Protégée (#): les attributs protégés sont accessibles
seulement dans la classe elle-même et aux classes
dérivées.
• Privée (-): les attributs privés sont accessibles seulement
par la classe elle-même.
 La notion de polymorphisme

C’est concept qui consiste à fournir une interface unique à

des entités pouvant avoir différents types. Par exemple, la
multiplication peut ainsi être étendues à des scalaires aux
vecteurs ou aux matrices, l'addition, des scalaires aux
fonctions ou aux chaînes de caractères, etc….
 La notion de polymorphisme

Le polymorphisme paramétrique, appelé généricité, représente

la possibilité de définir plusieurs fonctions de même nom mais
possédant des paramètres différents (en nombre et/ou en type).
Le polymorphisme paramétrique rend ainsi possible le choix
automatique de la bonne méthode à adopter en fonction du
type de donnée passée en paramètre.
 Introduction
Structures de données renfermant plusieurs types différents
– Exemple : type personne contenant les nom, prénom, et age
d’une personne :
type personne
character ( len=30) : : nom , prenom
integer : : age
end type personne

On peut alors déclarer des variables de ce type, comme pour

n’importe quel type
 Les champs
Les différentes variables d’un type dérivé sont appelées
champs. On y accède avec le caractère %, et on peut utiliser le
constructeur de même nom que le type pour les initialiser

etudiant1=personne (‘Cesar’,’Jules’, 57)

etudiant2=etudiant1
print ∗, etudiant2
do i=1,2
print ∗,‘nom, prenom , age’
read ∗, td (i)%nom,td(i)%prenom,td(i)%age
end do
print ∗,td (1)
 Constructeurs de structures
Lors de la valorisation d’un type dérivé via un constructeur de
structure, il est désormais possible d’affecter les composantes par
mots clés :
Exemple
type couleur
character ( len =25) :: nom
integer , dimension (3) :: code_rvb
end type couleur
...
type ( couleur ) :: c
...
c = couleur ( nom =" rose_saumon ", code_rvb =[ 250 , 128 , 114 ])
Les variables type dérivé(exemple)
type Etudiant
integer :: annee
character(len=10) :: specialite, institut
real :: montant_bourse
real :: moyen_annuel
end type Etudiant

...
type Etudiant :: yassmine
...
Les variables type dérivé(exemple)
...
type Etudiant :: yassmine
...

yassmine%annee=2
yassmine%specialite=mecanique
yassmine%institut=g.meca
yassmine%montant_bourse=1250078
yassmine%moyen_annuel=14.25
 Les modules
Un module est une unité de programme particulière introduite en
Fortran 90 pour encapsuler entre autres des données et des définitions
de types dérivés, des procédures (après l’instruction CONTAINS)
Quel que soit le nombre d’accès (USE) au même module, les entités ainsi
définies sont uniques.
Doit être compilé séparément avant de pouvoir être utilisé. Le
compilateur crée pour chaque fichier source : un fichier objet de même
nom suffixé par .o, autant de fichiers nom_module.mod qu’il y a de
modules
Si un module fait appel (USE) à d’autres modules, ces derniers doivent
avoir été précédemment compilés
program amoi
Exemple
use alui
implicit none
type(gmres) :: gm
print *,"avant : ",gm%maxcom
gm%maxcomp=20
print *,"apres : ",gm%maxcomp
end program amoi

module alui
integer, parameter :: d = selected_real_kind(15)
type gmres
real(kind=d) :: tol=1.D-12, relax=1.85_d
integer :: maxiter=50
integer :: maxcomp=10
end type gmres
end module alui
Exemple

module YSM_mod
type YSM
intege r :: nn,m
real,dimension (:),allocatable :: a
integer,dimension (:) :: ia
integer,dimension (:) :: ja
end type YSM
Contains
subroutine YSMcreate (matr,m)
type (YSM) :: matr
integer :: m
. . .
end subroutine YSMcreate
end module YSM_mod
Exemple

module YSM_mod
type YSM
intege r :: nn,m
real,dimension (:),allocatable :: a
integer,dimension (:) :: ia
integer,dimension (:) :: ja
end type YSM
Contains
subroutine YSMcreate (matr,m)
type (YSM) :: matr
integer :: m
. . .
end subroutine YSMcreate
end module YSM_mod