1 Programmation Orientee Objet en CSharp (5)

Wooshi Programmation Oriente Objet en C# 27 fvrier 2010

Copyright Wooshi 2009 - 2010 Page | 1

Programmation Oriente Objet en C#

1 Introduction

1.1 Prsentation

Tout bon dveloppeur le sait, le code d'un programme doit tre propre, comment, facile

maintenir et amliorer.

Vous tes adepte de la programmation procdurale et souhaitez apprendre la programmation

objet ? Alors ce tutoriel est fait pour vous.

A travers celui-ci, vous dcouvrirez toutes les notions, aussi bien basiques qu'avances, de la

POO (Programmation Oriente Objet). Ces notions sont pour la plupart communes tous les

langages Objet (C#, Java, PHP, etc).

Voici un avant-got de ce qui vous attend :

Classe et objet

Attribut et visibilit

Constructeur et mthodes

Hritage

Interface et classes abstraites

Classe et mthodes gnriques

Classe scelle

En vrac, on peut galement parler d'initialiseur, d'indexeurs, de surcharge de mthodes et

d'oprateurs, de classes partielles, d'expressions lambda, de types anonymes, etc.

1.2 Le langage C#

Pour illustrer nos propos, nous utiliserons le langage C# (Prononcez C-sharp). Sachez

nanmoins que ce tutoriel peut tre suivi indpendamment du langage de programmation

utilis puisque que, comme dis plus haut, les notions de programmation objet sont les mmes

pour tous les langages.

C# est un langage apparu en 2001 et spcialement cre par Microsoft pour tre utilis avec le

Framework .NET. Microsoft a galement sorti durant cette mme anne Visual Studio, son

IDE (Integrated Development Environement) ddi au .NET.



Une nouvelle version, nomm Visual Studio 2010, sera disponible en avril prochain et

introduira galement le framework .NET 4.0

1.3 Prrequis

Premire chose dont nous aurons besoin pour raliser ce tutoriel, le framework .NET,

videmment. La version 3.5 SP1 est actuellement la dernire en date. Vous pouvez la

tlcharger directement depuis le centre de tlchargement Microsoft.

Les utilisateurs de Windows 7 n'auront pas besoin de le tlcharger ni de l'installer puisque ce

dernier est intgr de base dans le systme.

Deuxime lment, il nous faut bien videmment un outil de dveloppement. Microsoft met

disposition de tous, gratuitement, Visual Studio C# Express 2008, qui est une sous-version de

Visual Studio spcifique au C#.

Vous pouvez galement vous procurer la version RC de Visual Studio 2010 gratuitement.

Attention, il ne s'agit pas la version finale, qui elle, sera payante.

Si vous n'avez jamais fais de programmation oriente objet, il se peut fortement que ce

tutoriel vous paraisse complexe. Il y a beaucoup de notions retenir et je vous conseille

vivement de pratiquer en mme temps que vous suivez ce tutoriel.

Par ailleurs, vous devez dj avoir fais de la programmation avant d'attaquer ce tutoriel, nous

ne reviendrons pas sur les notions de fonctions, paramtres, variables, etc.

Pour vous faciliter la tche, vous pouvez ds maintenant rcuprer le projet Visual Studio qui

contient les diffrents fichiers que j'utiliserai tout au long de ce tutoriel.

Si l'image n'apparait pas, cliquez ici.

Une fois que Visual Studio est install, crez un nouveau projet en cliquant sur Fichier >

Nouveau > Projet, puis choisissez Application console.

Si tout va bien, vous devez obtenir cela :



Si c'est le cas, alors tout va bien, nous pouvons commencer !

2 Notions basiques

2.1 Contexte

Pour illustrer les notions de la POO que nous allons vous enseigner, nous utiliserons tout au

long de ce tutoriel l'exemple d'une gestion de banque.

Dans cette banque, les clients possderont au minimum un compte bancaire (ils pourront en

avoir plusieurs). Ce compte sera soit de type Courant, soit de type Epargne.

2.2 Classe et objet

Notion fondamentale et totalement indispensable la POO, la classe.

Une classe correspond la dfinition d'un ensemble d'entits partageant les mmes attributs,

les mmes oprations et la mme smantique. En fait, une classe sert modliser un lment

et va servir en tant que conteneur.

Dans notre cas, nous devons modliser des clients qui possderont des comptes bancaires.

Commenons donc par crer une classe Client.

Pour cela, sous Visual Studio, dans le panneau droit Solution Explorer, cliquez droit sur le

nom de votre projet (ConsoleApplication par dfaut), puis cliquez sur Ajouter > Classe.

Appelez votre classe Client, puis confirmez.

Visual Studio va alors vous crer votre premire classe grce au mot cl class.



Pour l'instant, il ne s'agit que d'une dfinition, votre classe est inutilisable en tant que telle.

Pour l'utiliser, il faut tout d'abord comprendre la notion d'objet.

Un objet, caractris par un nom, correspond l'instance d'une classe. Un objet regroupe un

ensemble d'informations qui correspondent en fait aux valeurs des attributs d'une mme

classe.

On peut alors crer un objet de type Client nomm monPremierClient, puis un autre nomm

monSecondClient, etc. Ces objets ainsi nomms permettront d'agir directement sur le

contenu de la classe Client.

Ces quelques lignes de codes, placer dans le fichier Program.cs (qui contient la mthode

Main et qui servira de point de dmarrage), servent instancier trois objets de type Client.

Pour instancier un objet, la syntaxe respecter est donc la suivante :

Nom_De_La_Classe identifiant = new Nom_De_La_Classe();

La deuxime partie, new Client(), correspond en fait l'appel du constructeur. Vous verrez

cette notion dans la partie 2.4.

Si ces deux notions vous paraissent pour l'instant trs abstraites, c'est normal, ne vous

inquitez pas. N'hsitez pas relire plusieurs fois les dfinitions, puis passez la suite.

2.3 Attributs, mthodes et visibilit

Pour le moment, notre classe est cre, mais elle est vide. Pour modliser nos clients travers

la classe du mme nom, il va falloir ajouter cette classe des attributs.

Un attribut correspond une variable stockant une information au sein d'une classe. Les

attributs sont en fait des caractristiques de la classe dans laquelle ils sont contenus.

Dans notre cas, qu'est-ce que qui caractrise un client ? Son nom, son prnom, son ge, sa

taille, son poids, son sexe, sa couleur de peau, etc. Nous allons donc crer ces attributs.



Voici quelques dtails sur les quatres attributs crs :

_nomClient de type chaine de caractre

_prenomClient de type chaine de caractre

_ageClient de type entier

_tailleClient de type double

Vous vous demandez probablement quoi sert le mot "cl" private ? Il s'agit de la visibilit

de nos attributs.

La visibilit sert dfinir les droits d'accs aux donnes. Il existe pour cela trois niveaux

correspondant trois mots cls :

public : Il s'agit du niveau le moins lev. Un attribut dfinit comme public sera

accessible depuis n'importe quel endroit.

private : Un attribut dfinit en tant que private ne sera accessible qu'au sein de la

classe dans laquelle il est dfinit. Il s'agit du plus haut niveau de protection.

protected : Les attributs dfinis en tant que protected seront accessibles au sein de la

classe dans laquelle ils sont dfinis, mais galement au sein de toutes les classes

drives. Cette notion sera explique plus tard, oubliez-la pour l'instant.

Par convention, les attributs de type private doivent commencer par un underscore "_" en C#.

De mme, tout attribut doit utiliser une notation dite lowerCamelCase, c'est--dire dont le

premier mot commence par une minuscule et tous les autres par une majuscule.

Par dfaut, en C#, les attributs et mthodes possde le niveau de protection private, donc

accessible uniquement au sein de la classe dans laquelle ils sont dfinis.

En fait, il existe un quatrime niveau de protection nomm internal. Sachez simplement que

celui-ci est utilis par dfaut sur les classes et permet, grossomodo, d'autoriser l'accs aux

classes dans tout votre projet.

Passons maintenant aux mthodes. Il s'agit en fait de fonctions dfinies au sein de votre

classe et qui vont vous permettre d'agir sur vos attributs. Tout comme les attributs justement,

les mthodes possdent un niveau de visibilit.

Voici un exemple :

Le premier lment (public) dfini la visibilit de la mthode. Le deuxime correspond au

type de retour, ici void puisqu'il n'y a aucun retour. Le troisime correspond au nom de la

mthode et le quatrime la signature de la mthode. Ici () puisqu'il n'y a aucun paramtre

passer.

"Console.WriteLine" sert tout simplement afficher le texte pass en paramtre dans le flux

de sortie standard, ici la console.



Puisque notre mthode est dclare comme public, cela signifie qu'elle est accessible depuis

n'importe o. Nous pouvons donc utiliser nos objets prcdemment dclars pour appeler

cette mthode.

Comme vous le voyez, c'est trs simple. Il suffit d'utiliser votre objet, puis de faire suivre

celui-ci du nom de la mthode spare d'un point. D'ailleurs, en mettant le point, Visual

Studio vous proposera automatiquement un ensemble d'attributs et mthodes accessibles.

Vous pouvez dornavant compiler votre projet et lancer l'application. Pour cela, cliquez sur

Dbugger > Lancer sans dbugger ou utilisez le raccourci Ctrl + F5. Si vous avez suivi le

tutoriel correctement, alors vous devriez voir apparatre le texte "Hello World !" affich dans

la console.

Comme vous l'avez vu, cette mthode n'utilise pas les attributs de notre classe Client, elle se

contente simplement d'afficher du texte. En effet, nous ne pouvons pas encore utiliser les

attributs puisque ceux-ci ne possdent pour l'instant aucune valeur.

2.4 Constructeur

Lorsque nous avons cr notre premier objet tout l'heure, je vous ai parl de constructeur. Il

s'agit en fait d'une mthode spciale qui sera appele lors de l'instanciation d'un objet et qui

servira initialiser les valeurs de vos attributs.

Voici un premier exemple :



Sa dfinition est la mme que pour n'importe quelle autre mthode ceci prs que le

constructeur ne ncessite pas de spcifier un type de retour. Son nom doit obligatoirement

correspondre au nom de votre classe.

Dans notre constructeur, nous initialisons les valeurs de chacun des attributs caractrisant

notre classe Client. Comme vous le voyez, vous pouvez utiliser des chaines de caractre, des

entiers et mme la valeur null.

Dans cet exemple, j'ai galement introduit le mot-cl this. Ce dernier fait rfrence l'objet

partir duquel il est appel. Ainsi, en appelant ce constructeur depuis votre objet

monPremierClient, this fera rfrence cet objet et initialisera les valeurs afin qu'elle soit

disponible uniquement pour l'instance de la classe Client en cours d'utilisation.

Imaginons maintenant que nous rcuprons des clients stocks dans une base de donnes.

Nous voulons instancier un objet pour chaque client et donner directement aux attributs les

valeurs rcupres dans la base.

C'est tout fait possible ! Il suffit simplement de spcifier un nouveau constructeur. En fait,

vous pouvez crer autant que constructeur que vous le souhaitez tant que leur signature est

diffrente.

Nous voici donc avec un nouveau constructeur qui prend cette fois-ci en paramtre quatre

valeurs afin d'initialiser nos attributs.

L'appel d'un constructeur avec des paramtres se fait de la mme manire qu'un constructeur

sans paramtre, la diffrence qu'il faut lui passer des valeurs.

Dans l'exemple ci-dessus, nous crons un objet de type Client nomm monClient. Les

attributs seront initialiss de la faon suivante :

_nomClient : "Skywalker"

_prenomClient : "Luke"

_ageClient : 30

_tailleClient : 1.80



Maintenant que nos attributs possdent tous une valeur, nous devrions pouvoir accder aux

donnes n'est-ce pas ? H bien non, toujours pas !

Rappelez-vous, nous avons dfini nos attributs avec le niveau de visibilit private ce qui les

rend inaccessibles en dehors de la classe dans laquelle ils sont dfinis.

2.5 Accesseur et mutateur

Pour rendre nos attributs accessibles en dehors de la classe, il va falloir crer ce que l'on

appelle des accesseurs (ou getter) et des mutateurs (ou setter). L encore, il ne s'agit ni plus

ni moins que de mthodes dont le but est d'accder aux donnes.

Les accesseurs serviront accder aux donnes en lecture, c'est--dire rcuprer les

donnes, tandis que les mutateurs permettront d'y accder en criture, c'est--dire de modifier

les valeurs des attributs. Pour le reste de ce tutoriel, j'utiliserais les mots getter et setter la

place d'accesseur et mutateurs, ces derniers tant trs peu utiliss.

Commenons avec un exemple pour accder au nom de notre client.

Pour que notre getter soit accessible n'importe o, nous lui donnons une visibilit public.

L'attribut tant de type chane de caractre (string), nous dfinissons le type string en tant que

valeur de retour pour notre getter.

Le nom de votre getter importe peu mais, par convention, ils sont souvent appels

Get+Nom_attribut en UpperCamelCase, c'est--dire avec une majuscule en dbut de chaque

mot.

Le contenu de la fonction est trs simple, il s'agit simplement de retourner la valeur de

l'attribut _nomClient faisant rfrence l'objet en cours d'utilisation (this).

Ainsi, bien que votre attribut soit priv, vous pourrez dornavant accder sa valeur depuis

n'importe quel endroit grce au getter publique que vous venez de crer.

Le principe du setter est exactement le mme, sauf qu'il s'agit cette fois de modifier les

donnes.



Les setter n'ayant aucune ncessit de retourner une valeur, ceux-ci sont dfinis avec void en

type de retour. Par convention, ils seront nomms Set+Nom_attribut eux aussi en

UpperCamelCase, tout comme toute autre mthode d'ailleurs.

Le contenu est trs simple galement puisqu'il s'agit simplement de l'affectation d'une valeur

notre attribut. Vous pourrez dornavant modifier les valeurs de vos attributs partir de

n'importe o.

Mettons tout de suite ceci en pratique.

Dans cet exemple :

1. Nous instancions un objet de type Client nomm monClient grce au constructeur sans paramtre.

2. Nous utilisons le setter nomm SetNomClient afin de donner la valeur "Toto" l'attribut _nomClient.

3. Nous affichons dans la console "Mon Client s'appelle Toto" grce l'appel du getter GetNomClient retournant la valeur de l'attribut _nomClient.

Pour vous entraner, vous pouvez dfinir les setter et getter relatif chaque attribut puis crer,

par exemple, une mthode ObtenirInformation() qui crirait dans la console l'ensemble des

informations connues sur le client.

2.6 Proprit et proprit automatique

Les proprits sont utilises pour rendre accessible les getter et setter via un nom commun.

Prenons directement un exemple en crant une proprit pour _prenomClient.



Notre proprit, quivalente un getter et setter combin, doit prendre comme type de retour

le type de l'attribut concern. Ici, il s'agit de _prenomClient, soit d'une chaine de caractre, la

mthode doit donc prendre un type string en tant que type de retour.

Le principe est trs simple. Au lieu de possder deux mthodes (getter et setter) spares, les

deux sont regroupes dans notre proprit au sein de deux blocs get et set. Cette dernire peut

tre appele comme une simple mthode et Visual Studio dcidera automatiquement si il doit

appeler le getter ou le setter.

Premire ligne, je pense que vous avez maintenant saisi le principe, nous instancions un objet

de type Client et nomm monClient.

A la deuxime ligne, nous utilisons notre proprit PrenomClient en tant que setter et

attribuons par le fait la valeur "Toto" l'attribut _prenomClient.

Troisime ligne, nous utilisons la proprit PrenomClient en tant que getter et rcuprons la

valeur contenu dans l'attribut _prenom afin de la stocker dans un string nomm prenomClient.

Nous affichons ensuite ce prenom dans la console.

La gestion des getter et setter devient ainsi transparent pour le dveloppeur qui n'a plus qu'

retenir le seul nom de la proprit.

Encore plus simple, il existe les proprits automatiques. Ces dernires combinent la fois

l'attribut, son setter et son getter.

Dans l'exemple suivant, nous "transformons" notre attribut _ageClient en proprit

automatique et mettons jour les constructeurs pour prendre en compte cette modification.



Comme vous le voyez, une simple ligne nous permet de dfinir notre proprit. Nous

obtenons donc :

L'quivalent d'un attribut nomm AgeClient de type entier

Un getter

Un setter

Son appel se fait comme une simple proprit.

Il est certes bien plus rapide d'utiliser une proprit que de crer un attribut, un setter et un

getter, mais il est tout aussi important de comprendre le fonctionnement de ces trois lments

lorsqu'ils sont dclars sparment.

2.7 Rcapitulatif

Cette premire partie a dj probablement due vous donner du fil retordre. Nanmoins, il

s'agit l de notions fondamentales qu'il faut absolument comprendre et matriser afin de passer

la suite.

Aussi, je vous je vous encourage vous entraner complter la classe Client pour

comprendre parfaitement ces premiers principe.

Voici un exemple de ce quoi votre classe complte pourrait ressembler.



Voici maintenant un exemple d'utilisation.

Pour clore cette premire partie, faisons un rapide rappel de tout ce que nous venons de voir.

Une classe correspond la dfinition d'un ensemble d'entits partageant les mmes

attributs et mthodes.

Un objet correspond l'instanciation d'une classe.

Chaque attribut et mthode possde un niveau de visibilit qui peut tre soit public,

c'est--dire accessible depuis n'importe o, soit private, c'est--dire accessible depuis

la classe uniquement, ou soit protected, c'est--dire accessible depuis la classe o il

est dfini et depuis les classes drives (notion que nous verrons dans la partie

suivante).

Pour que les attributs prennent des valeurs lorsque l'on instancie un objet, il faut

utiliser les constructeurs. Une classe peut contenir un nombre infini de constructeur

tant que ceux-ci ne possde pas la mme signature.

Pour accder aux attributs d'une classe, il faut utiliser des getter (lecture) et setter

(criture).

Une proprit regroupe la fois un getter et un setter relatif un mme attribut.

Une proprit automatique regroupe l'attribut, son getter et son setter.

Dans la partie suivante, vous apprendrez entre autre ce qu'est l'hritage, le mot cl static, les

interfaces, les classes abstraites et les classes imbriques.



3 Notions basiques, suite

3.1 L'hritage

Aprs avoir vu la cration des objets, l'initialisation des donnes (constructeur) et l'accs aux

donnes (getter/setter), nous allons nous attaquer des notions un peu plus volues.

Nanmoins, il s'agit toujours de notions fondamentales que vous devez absolument connatre

pour matriser la programmation oriente objet.

Rappelez-vous, dans notre cas de gestion de banque, chaque client doit possder au minimum

un compte. Ce compte contient un identifiant, un libelle, un solde et une date d'ouverture.

Pour la suite de cette partie, vous allez devoir crer la classe Compte. Les fainants peuvent

directement la rcuprer ci-dessous.

Si vous ne comprenez pas quelque chose dans cette classe, alors vous avez probablement mal

compris une notion explique dans la partie prcdente. La seule nouveaut est l'utilisation

d'un attribut de type DateTime qui sert, comme son nom l'indique, stocker une valeur



relative une date. Vous pouvez utiliser cette attribut en tant que string si vous souhaitez

simplifier son utilisation.

Pour notre exemple, je vous ai galement dis qu'un compte devait tre soit de type courant,

soit de type pargne. Alors, faut-il crer deux autres classes quasiment identique celle que

nous venons de crer ? Non ! C'est ici qu'intervient l'hritage.

L'hritage permet une classe d'hriter des donnes et mthodes d'une autre classe. On

obtiendra alors un systme classe fille/mre (ou encore classe drive/gnrique) qui nous

permettra de possder plusieurs classes possdant plus ou moins la mme dfinition, sans

pour autant crire deux fois cette mme classe.

Le principal intrt de l'hritage est de pouvoir ajouter des attributs et mthodes une classe

tout en profitant de ceux de la classe mre. C'est exactement ce qu'il nous faut puisque chaque

type de compte possde un identifiant, un libelle, un solde et une date d'ouverture, mais un

compte pargne doit galement possder un taux d'intrt et un plafond, alors que le compte

courant possde un dcouvert autoris.

Sachez galement qu'une classe drive ne peut pas possder un niveau de visibilit plus lev

que sa classe gnrique.

Voyons tout de suite comment crer une classe drive.

Enfantin non ? Il suffit simplement de faire suivre le nom de la classe d'un double point, puis

du nom de la classe gnrique. De ce simple fait, notre classe CompteCourant bnficiera des

attributs et mthodes de la classe Compte.

La programmation objet introduit galement l'hritage multiple. Il s'agit simplement du fait

qu'une classe puisse possder plusieurs classes gnriques. En C#, cette notion n'est pas

disponible, du moins pas avec le framework 3.5, actuellement standard.

Voici notre classe CompteCourant, entirement cre.



Au niveau des proprits, comme vous le voyez, seul DecouvertAutorise est cre. Notre

classe CompteCourant tant drive de Compte, celle-ci bnficie directement des attributs

IdCompte, LibelleCompte, SoldeCompte, DateOuvertureCompte de sa classe mre Compte.

La nouveaut, c'est au niveau des constructeurs avec l'introduction du mot-cl base. Celui-ci

fait rfrence au constructeur de la classe gnrique par rapport la classe dans laquelle il est

appel. Ici, il appellera le constructeur sans paramtre (Compte()) de la classe Compte.

La syntaxe est la mme que pour spcifier l'hritage entre deux classes, il suffit de crer le

constructeur CompteCourant() comme si de rien n'tait, puis de faire suivre ce dernier par

base() prcd d'un double point. De ce fait, les attributs de la classe Compte seront initialiss,

ainsi que l'attribut DecouvertAutorise, propre la classe CompteCourant.

Pour le deuxime constructeur, il s'agit du mme principe sauf que, cette fois, nous passons

des paramtres au constructeur. Pour pouvoir passer des paramtres au constructeur base(), il

faut absolument que ces derniers soient dfinis dans la signature du constructeur fille, soit ici

CompteCourant().

De ce fait, les attributs de la classe Compte seront initialiss avec les valeurs que vous aurez

passes en paramtre, tout comme pour l'attribut DecouvertAutorise, propre

CompteCourant.

Si vous avez compris le principe, vous devriez tre capable de raliser la classe

CompteEpargne. Celle-ci possde, en plus de tous les attributs d'un compte standard, un taux

d'intrt, ainsi qu'un plafond.



Le principe est exactement le mme et vous devriez normalement tre capable de comprendre

le code ci-dessus tout seul.

Pour utiliser des classes hrites, le principe est le mme qu'avec les classes standards. Voici

un exemple ci-dessous.

Dans un premier temps, nous instancions un objet monCompte de type Compte, tout ce qu'il y

a de plus normal. En deuxime, nous instancions un objet cc de type CompteCourant en

appelant le constructeur contenant des paramtres. Souvenez-vous, ce dernier va seulement

garder la valeur relative l'attribut DecouvertAutorise (ici, 1000) puis passer les autres au

constructeur de la classe mre Compte.



Troisime exemple avec un objet de type CompteEpargne. Cette fois-ci nous utilisons le

constructeur vide (qui va attribuer des valeurs par dfaut nos attributs) puis appelons les

mthodes de la classe mre Compte pour donner des valeurs nos attributs.

Comment se fait-il que l'appel de ces mthodes soit possible ? Car ces dernires sont dfinies

avec une visibilit public, donc accessible de n'importe o.

Mais dans ce cas, comment faire pour que celles-ci ne soient pas accessibles depuis n'importe

quel endroit, mais que nous y ayons toujours accs depuis notre classe drive ?

Dans la premire partie, je vous parlais d'un niveau de visibilit protected. C'est ici que celui-

ci intervient. Ce niveau de visibilit permet aux attributs et mthodes qui l'utilisent d'tre

accessibles uniquement depuis la classe dans laquelle ils sont dfinis et dans les classes

drives.

Voyons ce qu'il se passe si nous dfinissons le getter IdCompte en tant que protected.

Vous pouvez dornavant essayer de

rcuprer la valeur de IdCompte depuis votre fichier Program.cs, cela sera impossible. A

partir de maintenant, l'attribut IdCompte n'est accessible que dans la classe Compte et dans les

classes qui en drivent.

En revanche, nous pouvons par exemple crer une mthode recupererIdCompte() au sein de la

classe CompteEpargne qui, elle, nous autorisera rcuprer la valeur de cet attribut.



Dans l'exemple ci-dessus, la mthode recupererIdCompte, dclare avec une visiblit public,

nous permet d'accder la valeur de l'attribut IdCompte, pourtant dclar en tant que

protected.

Pour la suite de ce tutoriel, nous considrerons que le getter IdCompte est nouveau public.

3.2 Les classes scelles

Le principe des classes scelles en C# est trs simple, il s'agit simplement de rduire les

fonctionnalits d'hritage. Une classe scell, dfinie avec le mot cl sealed est une classe que

vous ne pouvez pas driver.

Ainsi, si nous dfinissons notre classe Compte en tant que classe scelle, il sera impossible de

crer nos classes ComtpeEpargne et compteCourant en tant que classes drives de Compte.

Pour la suite de ce tutoriel, nous repassons la classe Compte en tant que classe non scelle.

3.3 Le mot cl static

Voici une nouvelle notion fondamentale la POO, l'utilisations du mot-cl static. Celui-ci

peut s'appliquer aussi bien une classe, qu' un attribut ou une mthode. Nous traiterons ces

trois cas sparment.

Une mthode, attribut ou proprit dclare avec le mot cl static peut tre accessible sur une

classe mme si aucun n'objet de cette classe n'a t instanci.

Dans notre cas, imaginons que le taux d'intrt de nos comptes pargne soit fix 1.2%.

Plutt que d'initialiser ce taux 1.2 avec le constructeur, nous allons modifier l'attribut pour le

dfinir en tant que static. Ainsi, la valeur sera accessible tout moment sans instancier d'objet

de type CompteEpargne.



Comme vous le constatez, l'attribut static _interet est accessible alors que nous n'avons

instanci aucun objet.

Le principe est le mme pour les mthodes statiques. Ces dernires sont accessibles sans

instancier d'objet. Une mthode statique ne peut pas permettre d'accder des lments non

statiques.

Voici un exemple d'utilisation.

La mthode, dfinie en tant que mthode statique peut tre appele sans instancier d'objet. En

revanche, l'exemple suivant ne fonctionnera pas :

Enfin, les classes statiques :

Elles ne peuvent pas tre instancies

Elles doivent contenir uniquement des mthodes et attributs statiques

Elles sont scelles par dfaut (ne peuvent pas tre drives)

Elles ne peuvent pas contenir de constructeur

Voici un exemple d'utilisation de classe statique :



Notre classe InformationBanque contient un ensemble d'informations relatives la banque et

qui, par consquent ne changeront jamais, c'est pour cela qu'il est judicieux de dfinir cette

classe en tant que statique.

InformationBanque contient uniquement des mthodes et attributs statiques. Le contraire

engendrerait un problme lors de la compilation.

Ce qu'il faut retenir :

Une classe statique ne contient que des lments statiques, mais des lments statiques

ne sont pas forcment contenus dans une classe statique.

Les mthodes et attributs dfinis comme statiques sont accessibles sans instancier

d'objet.

3.4 Les classes abstraites

Dans la partie 3.2, nous vous apprenions ce qu'tait une classe scelle, c'est--dire une classe

qui ne peut pas tre drive. Les classes abstraites sont en quelques sortes l'inverse des

classes scelles, il s'agit de classe qui doivent tre drives pour tre utilisable.

En effet, une classe dclare en tant que classe abstraite n'est pas instanciable. En revanche,

contrairement une classe static, elle n'est pas accessible, ce qui la rend inutilisable en tant

que telle.

Pour revenir notre exemple, si l'on rflchit bien au contexte, un compte est soit un compte

pargne, soit un compte courant, mais ne peut pas tre un compte tout simplement. Dans ce

cas, il serait logique de dfinir notre classe Compte en tant que classe abstraite afin que cette

dernire ne puisse pas tre instancie.



Il suffit simplement de rajouter le mot abstract devant le mot-cl class. Cette simple

modification nous empche d'instancier tout objet de type Compte. Vous pouvez essayer de le

faire via l'exemple utilis prcdemment, vous obtiendrez une erreur lors de la compilation.

En revanche, cela ne change absolument rien pour nos classes CompteEpargne et

CompteCourant. Ces deux classes drivent toujours de la classe Compte et peuvent toujours

tre instancies et utilisables.

Sachez qu'il est galement possible de dfinir des mthodes abstraites. Celles-ci doivent alors

:

Etre obligatoirement contenues dans une classe abstraite.

Ne contenir qu'une signature et aucune dfinition.

Etre obligatoirement implmentes dans toute classe drive.

Ceci faisant appel un concept avanc de la POO, nous n'en parlerons pas plus pour l'instant.

Vous retrouverez cette notion explique plus en dtail dans les parties suivantes.

3.5 Les interfaces

Les interfaces sont trs proches des classes abstraites.

Une interface dfinit un contrat que la classe qui l'implmente doit respecter. Les

interfaces ne peuvent pas tre instancies.

Au lieu de parler de drivation, on parle d'implmentation.

Une interface ne possde que des mthodes. (En fait, elle peut possder galement

d'autres lments que nous verrons dans la partie avance de ce tutoriel).

Lorsqu'une classe implmente une interface, cette classe doit obligatoirement

implmenter toutes ses mthodes.

Les mthodes dclares dans les interfaces ne possdent pas de dfinition.

La dclaration d'une interface se fait grce au mot-cl interface.



Par convention, le nom d'une interface doit toujours commenc par "I". Dans notre exemple,

IComparable est une interface propre au framework .NET, vous n'avez donc pas la redfinir.

L'interface comporte une unique mthode, CompareTo, qui prend en paramtre un objet.

Admettons que notre classe Compte ait besoin de cette interface. Cette dernire devra alors

implmenter la mthode CompareTo, sous peine de rencontrer une erreur lors de la

compilation.

L'implmentation d'une interface se fait de la mme faon que l'hritage d'une classe

gnrique, il suffit de sparer le nom des deux classes par un double-point.

Contrairement l'hritage, une classe peut implmenter plusieurs interfaces. De mme, une

classe peut hriter d'une autre classe tout en implmentant une ou plusieurs interfaces. Pour

cela, il suffit de sparer les classes gnriques et interfaces par des virgules.

Dans notre exemple, la classe CompteEpargne hrite de la classe Compte, mais implmente

galement les interfaces IComparable et ICloneable.

3.6 Les classes imbriques

Jusqu' maintenant, nous savions qu'une classe pouvait contenir des attributs, des proprits et

des mthodes. Mais ce n'est pas tout, les classes peuvent aussi contenir d'autres classes. Ce

principe s'appelle classe imbrique.



Les classes imbriques sont souvent utilises pour structurer une classe en diffrente sous

classes qui n'auraient pas de relles significations si elles taient dclares sparment. Cette

notion permet galement de cacher cette classe aux utilisateurs.

Seule une classe imbrique peut tre dfinie avec un niveau de visibilit private ou

protected.

Voici un exemple avec une classe Bijoux dclare en tant que classe imbrique dans la classe

Client.

Dfinie comme telle, la classe Bijoux ne sera accessible que depuis la classe Client. Cette

notion tant assez peu utilise, nous ne dtaillerons pas plus son utilisation.

3.7 Initialisateur d'objets

Pour clore cette partie, nous allons voir ce qu'est un initialisateur d'objet. Cette notion est trs

simple, il s'agit d'une faon d'initialiser les valeurs des attributs d'un objet lors de sa dfinition

sans pour autant utiliser le constructeur.

Pour cela, reprenons la dfinition de notre classe Client.



Lors de la cration d'un objet Client, au lieu d'utiliser le constructeur, nous pouvez utiliser

l'initialisateur d'objet pour accder aux attributs et proprits accessibles. Ici, on pourra

initialiser les valeurs des proprits AgeClient et TailleClient, puisque ces dernires sont

dfinies en tant que public.

Le bout de code ci-dessus est quivalent :

Pour utiliser l'initialisateur d'objet, il suffit simplement d'instancier son objet sans appeler le

constructeur, puis de spcifier les diffrents attributs et/ou proprits spars par des virgule,

le tout entre accolades.

3.8 Rcapitulatif

Beaucoup de notions ont t vues dans cette deuxime parties ddies aux notions basiques de

la programmation oriente objet. Encore une fois, il est fort probable que vous ne les ayez pas

toutes saisies du premier coup. Je vous encourage donc les revoir afin de les matriser pour

la suite.

Voici un petit rcapitulatif des notions vues dans cette seconde partie :

L'hritage permet une classe de driver d'une autre classe en lui permettant d'accder

ses attributs et mthodes.

Les attributs et mthodes dclars avec un niveau de visibilit protected sont

accessibles depuis la classe dans laquelle ils sont dclars et dans les classes drivs.

Les classes scelles ne peuvent pas tre drives.

Les classes abstraites doivent tre drives pour tre utiles.

Une classe abstraite peut contenir des mthodes non abstraites.

Le mot cl static utilis sur des attributs ou mthodes permet d'y accder sans avoir

besoin d'instancier d'objet.

Une classe statique ne peut pas tre instancie, ne doit contenir que des lments

statiques et est scelle par dfaut.

Une interface dfinit un contrat que la classe qui l'implmente doit respecter.

Les mthodes dfinies dans une interface ne doivent pas contenir de dfinition et

doivent tre obligatoirement redfinis dans la classe qui implmente cette interface.

Les classes imbriques permettent de structurer des classes qui n'auraient aucune

signification si elles taient dfinies sparment.



L'initialisateur d'objet permet d'initialiser les valeurs des attributs accessibles d'une

classe, sans pour autant appeler de constructeur lorsque l'on instancie un objet.

Dans la prochaine partie, nous attaquerons les notions avances. En vrac, nous pouvons citer

les classes et mthodes partielles, les expressions lambda, la surcharge d'oprateur et de

mthode, les types anonymes, les indexeurs, etc.

Quoi qu'il en soit, si vous matrisez dj toutes les notions vues jusqu' maintenant, vous tes

tout fait capable de faire un programme correct. Les notions avances sont, certes, trs

puissantes, mais pas indispensables.

[Pour l'instant, ce tutoriel s'arrte l. Il sera mis jour trs prochainement avec l'ajout des

notions avances]

Documents

1 Programmation Orientee Objet en CSharp (5)