Voici un petit tutorial pour vous aider à comprendre ce qu'est un langage orienté objet.
Avec ceci vous aurez un aperçu des possibilités du C# et donc de RunUO.
Vous apprendrez aussi quelques thermes du langage, comme instance et membre.
La programmation orientée objets :
Le langage C# est un langage objets. La programmation objet est un moyen de créer un programme informatique sous la forme d'un ensemble d'objets ayant un rôle précis et déterminer qui, en interagissant ensemble, vont conduire à un résultat.
En objet il faut répondre à un programme avec les éléments de ce programme. Si l'on a un programme de gestion de personnes, il faudra alors avoir des objets représentant ces personnes. Ces objets contiendront des cases nom, prénom, date de naissance, ect. Tout ce qui définit une personne. Dans l'univers du programme, il faut imaginer un monde ou tout éléments est un objet.
Les objets peuvent être regroupés en catégories appelées "classes". Si notre programme concernait "la vie", nous pourrions alors créer la classe ANIMAL et la classe VEGETALE. Il nous serait alors possible de gérer les classes CHIEN, CHAT et LAPIN en les faisant dériver de la classe ANIMAL. De même, nous pourrions créer les classes BUISSONS, ARBRE et LEGUME de VEGETALE.
Cette dérivation de classes vers des "sous-classes", ou "classes filles", peut se faire sans limites. Il est ainsi possible de créer les classes CANICHE et LABRADOR à partir de la classe CHIEN. Si cette façon de voir l'univers n'est représentative de la vie réelle, l'important est que ce soit le reflet de notre programme informatique.
| CODE |
TIPS : Classes filles
Une "classe fille" est une classe qui a repris certaines particularités de la classe dont elle est dérivée (que l'on nommera pour l'occasion "classe mère". Ce lien qui lie la fille à sa mère se nome "héritage". On a aussi pour habitude de dire qu'un classe fille "étend" sa classe mère.
|
Les instances de classe :
Une classe (avec un peu d'imagination) peut être imaginée comme un moule. A partir de la classe CANICHE, il est possible de créer autant d'objets caniches que nous le désirons et de les insérer dans l'univers de notre programme. Cela s'applique pour toutes les classes que nous venons de créer.
"Imaginons que nous voulons créer un caniche nommer pepette"
Dans cette exemple, Pepette est une instance de la classe caniche. Le lien entre CHIEN et ANIMAL n'est pas le même que le lien entre Pepette et CHIEN.
Toute classe peut ainsi avoir un ou plusieurs "représentants", qui possèdent les caractéristiques de la classe dont ils sont issus.
Les membres d'instances :
Nous pouvons créer un grand nombre d'objets, mais ceux-ci n'ont pas grand intérêt. Mis à part leur typer (CANICHE,LABRADOR,POMMIER,ect...), nous ne savons pas grand-chose sur eux, et ils ne peuvent rien faire. Nous allons donc ajouter des caractéristiques à notre classe. Ces caractéristiques se nomment les "membres de classes".
| CODE |
TIPS : Membres et instances :
Il ne faut pas confondre les instances d'une classe, qui sont les objets crées à partir d'une classe (comme pepette et caniche), avec les membres d'une classe, qui sont les caractéristiques de cette classe.
|
Pour rendre nos objets un peu plus utiles, nous pourrions améliorer très simplement notre modèle en ajoutant des membres(caractéristiques) à la classe CANICHE et LABRADOR. Nous ajouterons les membres(caractéristiques) "nombreDePattes", "couleurPelage", "taille", "age" et "nom" à la classe CANICHE, nous feront le même pour LABRADOR. Ces membres(caractéristiques) sont des variables qui nous permettent d'associer des valeurs à chacun de nos objets.
Si nous voulons en plus faire en sorte que nos objets puissent faire des actions, nous ajouterons aux classes des "méthodes". Les méthodes ont pour but de renvoyer des valeurs ou bien de modifier l'environnement. Nous pourrions ainsi adjoindre à CANICHE et LABRADOR une méthode Manger(). Nous pourrions de même créer des méthodes Vieillir(), se Déplacer() et Dormir()
Si notre programme devient de plus en plus complet, il souffre ici de graves défauts.
| CODE |
Animal
Chien Chat Lapin
/////////////////
//Caniche
//
//nombreDePattes
//couleurPelage
//taille
//age
//nom
//____
//Manger()
//Dormir()
//Deplacer()
//Vieillir()
//SetAge()
//GetAge()
//SetNom()
//GetNom()
//...
//////////////////
//////////////////
//Labrador
//
//nombreDePattes
//couleurPelage
//taille
//age
//nom
//____
//Manger()
//Dormir()
//Deplacer()
//Vieillir()
//SetAge()
//GetAge()
//SetNom()
//GetNom()
//...
//////////////////
|
| CODE |
TIPS : Accesseur et mutateur :
Un "accesseur" est une méthode qui renvoie la valeur d'une des variables d'un objets. Nous pourrions ajouter aux classes CANICHE et LABRADOR un accesseur GetAge(), qui renverrait l'âge d'un CANICHE ou LABRADOR permettant à un objet extérieur d'accéder à cette valeur. Les accesseur prennent généralement comme nom celui de la variable auquel on associe un préfixe "Get".
Un "mutateur" est une méthode qui permet de changer le variable d'un objet. De nouveau, pour l'âge, nous pourrions créer la méthode SetAge(), qui permettrait à un objet extérieur de modifier l'âge d'un CANICHE ou LABRADOR. Les mutateurs prennent généralement comme nom celui de la variable auquel on associe le préfixe "Set".
|
| CODE |
Tips : Variables et méthodes
Les méthodes sont faciles à différencier des variables, car elles sont terminées par des parenthèses ouvrantes et fermantes.
|
L'héritage :
Notre modèle est ici mal conçu. Un grand nombres de redondance sont perceptibles. La classe CANICHE et LABRADOR ont un grand nombre de membres(caractéristiques) identiques, que ce soit des variables ou des méthodes. Ces membres seront identiques dans les classes LAPIN et CHAT. Il serait donc plus intelligent de les mettres dans la classe mère ANIMAL. Les classes filles CHIEN, LAPIN et CHAT hériteraient de tous les membres de la classe ANIMAL. Celle-ci contiendra tout les membres qui sont en commun à ses classes filles.
Lorsqu'une classe héritera de ANIMAL, elle possédera tous ses membres(caractéristiques) automatiquement, même si nous pourrons lui ajouter des membres à part.
Nous donnerons par exemple les membres Aboyer(), Grogner(), et MonterLaGarde() à la classe CHIEN, qui s'ajouteront aux memebres hérités de la classe Animal. La classe CHAT aura les méthodes DetecterChien() et SEnfuir().
Nous n'avons plus qu'a construire d'autres instances des objets CANICHE et LABRADOR, d'autres objets de type CHAT et LAPIN, nous pouvons mettre des arbres, des buissons et des fleurs.
| CODE |
//////////////
//Animal
//
//nombreDePattes
//couleurPelage
//taille
//age
//nom
//_____
//Manger()
//Dormir()
//Deplacer()
//Vieillir()
//SetAge()
//GetAge()
//SetNom()
//GetNom()
//...
//////////////////
//////////////// ///////////////// //////////
//Chien //Chat //Lapin
// // //////////
//Aboyer() //Miauler()
//Grogner() //DetecterChien()
//MonterLaGarde() //SEnfuir()
/////////////// /////////////////
///////////////
//Labrador
//
//GuiderAveugle()
//DetectDrogue()
///////////////
**********
**Labra1**
**4 **
**jaune **
**90 **
**7 **
**Rex **
**********
|
Membres statiques ou membres de classes :
Contrairement aux membres d'instances d'une classe, qui se transmettent à la sous-classe, les membres statiques restent dans la classe elle-même. Etant stocker dans la classe, leur valeur s'applique à la classe, mais aussi à l'ensemble de ses instances(sous-classes).
Avec les membres d'instances, chaques instance d'une classe reçoit une nouvelle copie des membres d'instance de la classe héritée. Toutes les instances peuvent modifier ces membres sans affecter ceux des autres. Avec les membres des classes, il n'existe qu'un seul membre commun à tous les objets. Donc une seul et même variable pour toutes les instances(sous-classes). Si la valeur de ce membre est modifiée, toutes les instances de la classe seront affectées par la modification.
Nous savons donc qu'un membre d'instance crée une nouvelle variable pour chacune des instances de la classe, alors qu'un membre statique garde une seul et même variable pour toutes ses instances. Si nous créons une classe Famille, nous pourrons créer un membre d'instance "prenom", Mais il serait inutile de créer un membre d'instance "Nom" pour chacunes des instances, car elles auront le même nom de famille. Nous créerons un membre statique auquel tous les objets auront accès.
Polymorphisme :
Il arrive souvent qu eplusieurs objets de nature différente disposent de fonctionnalités en commun. Ces objets ont donc le même comportement et peuvent être utilisés exactement de la même manière. Ainsi prenons come exemple un douanier à qui l'on a demander d'intercepter toute personnes passant la frontière avec une boisson alcoolisée à la main. Si nous regardons ce qui se passe dans la réalité, nous verrons notre douanier arrêter les personnes portant du whisky, de la bière, du vin rouge, du champagne,...
Pourtant, réaliser cet effet dans un programme sans recourir à la technique du polymorphisme s'avère très difficile. Il faudra apprendre au douanier à reconnaître TOUS les types d'alcools existant dans le monde. Si nous imaginons trois cent classes correspondant à trois cent alcools différents, la tâche du programmeur peut s'avérer difficile.
Si on regarde de plus près ont peut remarquer que tous ces alcool ont des points communs : le dégrés d'alcool, ou le lieu de fabrication, la couleur, ect...
Nous devrions donc créer une classe mère, qu'on nommerais ALCOOL et dont toutes les classes hériteraient. Nous savons que quand une classe hérite d'une autre classe, elle est du type de sa classe, mais aussi de la classe dont elle hérite. Il suffira donc au douanier de savoir si la boisson est du type alcool pour pouvoir exercer son métier.
Les objets peuvent donc être de plusieurs types différents, selon l'héritages qu'ils affectent. Ces objets sont qualifié de "Polymorphisme" en raison du fait, qu'ils peuvent avoir plusieurs aspects différents selon l'héritage considéré.
Le polymorphisme permet donc de simplifier les traitements communs applicables à différents tyèpes d'objets en les rendants communs à tous ces objets. C'et l'un des intérêts majeurs de la programmation orientée objets. Tous les objets sont des objets de la classe communes, et ils peuvent donc être maipulés uniformément à travers l'interface de cette classe, même s'ils appartiennent à des classes filles différentes. L'héritage permet donc de traiter les objets d'une hiérarchie de classe comme des objets polymorphiques et, ainsi, de simplifier grandement la gestion des objets de cette hiérarchie.
| CODE |
Tips : Usage Typographique
Voici l'usage courant du langage C#
*Tous les noms de classes commencent par une majuscule (Chien, Chat, Tulipe, ect...)
*Les noms de variables commencent par une lettre minuscule et les noms des méthodes par une majuscule (Manger(),age,ect...). Si ce nom est composé de plusieurs mots, alors chacun d'eux, hormis le premier, commencera par une majuscule (SetAge(), couleurPelage, ect...).
|
Signé : Shariz l'ami des plus petits.
---------------------------------------------------------------------------------------
Référence :
MICRO Application Référence : Le Langage C# (3086) par Valentin Billotte - Marc Thevenet
Bouquin de référence(Site de MicroApplication)
édité :
:blink: je viens de trouver ça! Tous ce mal pour rien.
La vrai version du tutorial.....
plus ça :P
Cours de C# 
