Académique Documents
Professionnel Documents
Culture Documents
Une classe c’est un plan ou un modèle sur lequel on va baser pour créer (instancier) des objets. Définir
une classe c’est créer un nouveau type, ou ajouter un type personnalisé au jargon des types.
Il faudra énumérer toutes les propriétés de cet objet et toutes les méthodes qui vont permettre de définir
son comportement.
La déclaration d’un nouveau type de données et les méthodes qui permettent de gérer les objets
associés, constitue une classe de l’objet.
Les propriétés de l’objet seront implantées sous la forme de données membres de la classe.
Les différentes fonctions ou méthodes seront implémentées sous la forme de méthodes membres
de la classe.
De façon courante, données membres et méthodes membres, sont considérées respectivement
comme synonymes de propriétés et méthodes de la classe.
Exemple :
5. Le mot-clé this
Le mot-clé this désigne, dans une classe, l'instance courante de la classe elle-même.
6. L’instanciation
Pour qu’un objet ait une existence, il faut qu’il soit instancié. Une même classe peut être instanciée plusieurs
fois, chaque instance (objet) a des propriétés spécifiques.
En C# il n’existe qu’une seule manière de créer une instance d’une classe. Cette création d’instance peut se
faire en deux temps :
class Program {
public static void Main(string[]args){
Client cl;//déclaration
Cl = new Client( ) ; //instanciation
Client C2 = new Client() ; //déclaration et instanciation
}
}
7. Constructeurs
Le mot-clé this désigne, dans une classe, l'instance courante de la classe elle-même.
Un constructeur d’une classe donnée intervient au moment de l’instanciation d’un objet de type cette classe.
Le constructeur initialise les attributs (propriétés) de cet objet pour qu’il soit cohérent. Le constructeur est
une méthode de la classe, mais particulière :
public Client( ){
- Le constructeur par défaut : Un constructeur par défaut est un constructeur qui peut être appelé sans
paramètre. À noter qu'il peut s'agir d'un constructeur sans paramètres, ou d'un constructeur dont les
paramètres ont des valeurs par défaut.
Exemple :
public class Client {
//Déclaration d’attributs
// ....
//constructeur d’initialisation
// ....
//constructeur par defaut
public Client ( ){
}
}
class Program {
public static void main(String[]args){
Client cli=new Client();
}
}
- Constructeur de recopie : Le constructeur de recopie permet de copier les propriétés d’un objet existant
dans la nouvelle instance.
Exemple :
public class Client {
//Déclaration d’attributs
// ....
//constructeur d’initialisation
// ....
Programme principal :
class Program {
public static void Main(string[]args){
Client clt1=new Client( ); //C. par défaut
Client clt2=new Client(22, "Mohamed", 20000) ; //C. d’initialisation
Client clt3=new Client(clt2) ; //Constructeur de recopie
}
}
En programmation orientée objet, on évite d’accéder directement aux propriétés par l’opérateur « . » en effet
cette possibilité ne correspond pas au principe de l’encapsulation. Certains langages interdisent carrément cet
accès direct à la propriété et méthodes. En C# c’est le programmeur qui choisit si une propriété ou méthode
membre est accessible directement ou pas.
Par défaut en C # toutes les propriétés et méthodes ne sont pas accessibles directement. Il faut donc préciser
explicitement le mode d’accès à chaque propriété et chaque méthode. Pour cela il existe trois mots clés
public : après ce mot clé toutes les propriétés et méthodes sont accessibles directement à l’extérieur de la
classe.
private : après ce mot clé toutes les propriétés et méthodes sont verrouillées, inaccessibles directement à
l’extérieur de la classe, elles sont accessibles qu’à partir des méthodes public membres de la classe.
protected : après ce mot clé toutes les propriétés et méthodes membres de la classe sont verrouillées,
néanmoins elles sont accessibles dans les classes filles, ou à partir des méthodes public de la classe.
La distinction entre private et protected, n’est visible que dans le cas de déclaration de nouvelles classes par
héritage. Ce concept sera abordé ultérieurement dans ce cours.
Afin d’appliquer correctement le principe d’Encapsulation, il convient de verrouiller l’accès aux propriétés
en les déclarant private, tout en autorisant l’accès aux méthodes en les déclarant public.
Exemple :
L'attribut nom n'est pas accessible directement. Elle est accessible qu’à partir de la méthode
modifierNom(string n) .
Si les propriétés sont verrouillées (déclarées private) on ne peut plus y accéder de l’extérieur de la classe. Il
faut donc créer des méthodes dédiées à l’accès des propriétés pour chacune d’elle, ces méthodes doivent
permettre un accès dans les deux sens :
Cette fonction pourra être utilisée dans la fonction main comme suit :
Ces méthodes sont appelées méthodes Set. Cette méthode ne retourne aucune réponse. Par contre un paramètre
de même type que la propriété doit lui être indiqué.
Toujours pour la propriété num de type int, le Setter associé sera implémenté comme suit :
Cette fonction pourra être utilisée dans la fonction main comme suit :
c.SetNum(5); // OK
En C #, chaque classe peut avoir un compteur d’instance qui a comme valeur le nombre d’instances en cours,
instanciées à partir de cette classe à un moment donnée.
Ce compteur d’instance n’est qu’une propriété de classe, sa valeur est la même pour toutes les instances,
pour déclarer cette propriété on utilise le mot static.
La propriété de la classe doit être initialisée par 0 lors de sa déclaration, et incrémentée de 1 dans tous les
constructeurs de la classe.
Exemple :
Public class Client {
//propriété d’insttance
private int num ;
private string nom ;
private double chiffre_affaire;
//propriété de classe
private static int compteur=0 ;
//Constructeur d’initialisation
public Client(int num, string nom, double ca){
compteur+=1 ;
This.num=num ;
This.nom=nom ;
This.ca=ca ;
}
}
L’appel d’une méthode de statique est sensiblement différent à l’appel des autres méthodes. En effet, il ne
faut pas utiliser l’instance de la classe, il faut utiliser la classe elle-même.
11. L’héritage :
a) Concept :
Le concept de l’héritage est l’un des trois principaux fondements de la programmation orientée objet, le
premier étant l’encapsulation, est le dernier est le polymorphisme qui sera abordé plus tard dans ce
document.
L’héritage consiste à la créer une nouvelle classe dite classe drivée ou classe fille à partir d’une classe
existante dite classe de base ou classe parente ou classe mère.
L’héritage permet de :
Récupérer le comportement standard d’une classe objet (classe parente) à partir de propriétés et de
méthodes définies dans celle-ci.
Ajouter des fonctionnalités supplémentaires en créant de nouvelles propriétés et méthodes dans la
classe dérivée.
Modifier le comportement standard d’une classe d’objet (classe parente), en surchargeant certaines
méthodes de la classe parente dans la classe dérivée.
La classe de base :
class ClassA {
//propriété de la classe
public int DataA ;
//Méthode de la classe
public int FonctionA1(){
//code de la fonction fonctionA1
}
public virtual int FonctionA2() //surchargeable
{
//code de la méthode fonctionA2
}
}
La classe fille :
class ClassB : ClassA{
//propriétés de la classe ClassB
public int DataB ;
//Méthodes de la classe ClassB
public override int FonctionA2(){
//code de la méthode FonctionA2
}
public int FonctionB1(){
//code de la méthode FonctionB1
}
}
DataA1, DataA2 et DataA3 sont des propriétés de la classe ClasseA respectivement private, protected
et public.
FonctionA est une méthode de ClasseA, et FonctionB est une méthode de ClasseB.
DatA1, DataA2 et DataA3 sont des propriétés de ClasseA. Elles sont donc directement accessibles
dans toutes les méthodes ClasseA, donc dans FonctionA.
DataB est propriété de ClasseB (classe dérivée de ClasseA). Une propriété d’une classe dérivée est
inaccessible dans la classe de base.
DataA1 est déclarée private dans la classe ClasseA. Elle est accessible uniquement pour toutes les
fonctions de la classe ClasseA.
DataA2 est déclarée protected dans la classe ClasseA. Elle est accessible uniquement pour toutes les
fonctions des classes ClasseA et ClasseB.
DataA3 est déclarée public dans la classe ClasseA. Elle est donc directement accessible dans toutes
les instances.
c) Compatibilité et affectation :
Lors des affectations (opérateur =), il est possible de mélanger des instances de classes différentes. Cependant,
il y a quelques règles à observer :
ClasseA ObjA ;
ClasseB ObjB ;
d) Constructeur et héritage
Chaque constructeur d'une classe dérivée doit obligatoirement appeler le constructeur équivalent de
la classe de base. Cela se fait de la façon suivante en utilisant le mot-clé base :
Exemple :
class Rectangle {
private int largeur ;
private int longueur ;
public Rectangle(){ }
public Rectangle(int largeur , int longueur){
this.largeur=largeur ;
this.longueur=longueur ;
}
//...
}
Pour remédier à ce problème on doit surcharger la fonction ToString dans la classe Rectangle. On va la
surcharger (redéfinir), et on ne va pas la définir parce que c’est une méthode virtual héritée de la super class
Object.
class Rectangle {
private int largeur ;
private int longueur ;
public Rectangle(){ }
public Rectangle(int largeur , int longueur){
this.largeur=largeur ;
this.longueur=longueur ;
}
public Rectangle(Rectangle r){
this.largeur= r.largeur ;
this.longueur= r.longueur ;
}
//...
}
public static void Main(string[]args){
Pour remédier à ce problème on doit surcharger la méthode Equals dans la classe Rectangle, une fois surchargé
la méthode Equal sera implicitement (par défaut), à chaque fois on veut comparer deux objets de type
Rectangle en utilise l’opérateur « == »
Les tableaux contiennent des éléments, chacun d’eux étant repéré par son indice. En C#, il existe une manière
très simple de créer des tableaux « classiques », sans faire référence aux classes Collections.
Une méthode déclarée abstract ne peut pas être exécutée. En fait, elle n'a pas d'existence réelle. Sa déclaration
indique simplement que les classes dérivées doivent la redéfinir.
Une classe qui contient une méthode abstract doit être déclarée abstract elle-même.
Exemple
aStr[0]= "Ahmed";
aStr[1]= "Farid";
aStr[2]= "Ali";
aStr[3]= "Ibrahim";
aStr[4]= "Mohamed";
Exemple :
Programme qui affiche tous les éléments d’un tableau statique nommé aTab :
Console.WriteLine(Val) ;
}
Ce programme stocke à chaque fois la valeur d’un élément du tableau aTab dans la variable intVal , puis
affiche cette dernière.
Using System.Collections ;
La classe ArrayList est un tableau dynamique auquel on peut rajouter ou insérer des éléments et en supprimer.
Il faut utiliser le namespace System.Collections
Accès à un élément :
Exemple :
//Parcourir le dictionnaire
Remarque:
Le dictionnaire Hashtable ne trie pas les éléments, et pour avoir un dictionnaire trié dans l’ordre croissant en
fonction de la clé de ses éléments, on doit utiliser la classe SortedList ou lieu de la classe Hashtable.
Exemple :
//afficher le dico sl
Exemple : List<T>
using System.Collections;
…
public static void Main(string[] args)
{
// creer 3 personnes
personne p1 = new personne("nom1", "prenom1", 23, "Ville1");
personne p2 = new personne("nom2", "prenom2", 24, "Ville2");
personne p3 = new personne("nom3", "prenom3", 25, "Ville3") ;
// creer la liste
List<personne> list = new List<personne>();
// remplir la liste
list.Add(p1);
list.Add(p2);
list.Add(p3);
// parcourir la liste 2eme méthode
foreach (personne p in list)
{
Console.WriteLine(p.ToString());
}
}
Exemple : HashSet<T>
...
// creer 4 personnes
personne p1 = new personne("nom1", "prenom1", 23, "Ville1");
personne p2 = new personne("nom2", "prenom2", 24, "Ville2");
personne p3 = new personne("nom3", "prenom3", 25, "Ville3");
// creer la liste
HashSet <personne> list = new Hashset <personne>();
// remplir la liste
list.Add(p1);
list.Add(p2);
list.Add(p3);
// parcourir la liste 2eme méthode
foreach (personne p in list)
{
Console.WriteLine(p.ToString());
}
...
using System.Collections;
…
public static void Main(string[] args)
{
// creer 3 personnes
personne p1 = new personne("nom1", "prenom1", 23, "Ville1");
personne p2 = new personne("nom2", "prenom2", 24, "Ville2");
personne p3 = new personne("nom3", "prenom3", 25, "Ville3");
// creer le SortedList
SortedList<string, personne> dic = new SortedList<string, personne> ();
// remplir le dictionnaire
dic.Add(p1.getNom(), p1);
dic.Add(p2.getNom(), p2);
dic.Add(p3.getNom(), p3);
// pour afficher les clés
foreach (String s in dic.Keys)
{
Console.WriteLine("la clé est : " +s) ;
}
// pour afficher les valeurs
foreach (personne p in dic.Values)
{
Console.WriteLine(p.ToString());
}
}
- La concaténation :
string s1 = "hello";
string s2 = "hello";
bool c1 = s1.Equals(s2);
//équivaut à
bool c1 = (s1 == s2);
Méthodes de String:
public int IndexOf(string value, int startIndex);
Retourner la première position dans la chaine de la chaîne value. La recherche commence à partir du
caractère numéro : startIndex.
public string Insert(int startIndex, string value);
Insère la chaîne value dans la chaîne en position startIndex.
public static string Join(string separator, string[] value);
Méthode de classe, qui retourne une chaîne créée par la jonction de plusieurs sous-chaînes contenues
dans le tableau value qui sont séparée par separator.
public string[] Split(char [] separator);
Divise une chaîne en sous-chaînes en fonction des caractères contenus dans le tableau separator.
Exemple :
// Affichage
----------------------------------
uneChaine=l'oiseau vole au-dessus des nuages
uneChaine.Length=34
chaine[10]=o
uneChaine.IndexOf("vole")=9
uneChaine.IndexOf("x")=-1
uneChaine.ToUpper()=L'OISEAU VOLE AU-DESSUS DES NUAGES
uneChaine.ToLower()=l'oiseau vole au-dessus des nuages
uneChaine.Replace('a','A')=l'oiseAu vole Au-dessus des nuAges
champs[0]=[l'oiseau]
champs[1]=[vole]
champs[2]=[au-dessus]
champs[3]=[des]
champs[4]=[nuages]
Join(":",champs)=l'oiseau:vole:au-dessus:des:nuages
(" abc ").Trim()=[abc]
La levée d'exceptions,
Le traitement d'exceptions.
Exemples des exceptions : affecter une valeur int à un string, un nombre divisé par zéro, ou entrée
inattendue (un utilisateur sélectionne un fichier inexistant).
Exemple :
try
{
Console.Write("Entrez un nombre : ");
int n = int.Parse(Console.ReadLine());
Console.WriteLine( "100/nombre = {0}", 100/n);
}
catch (DivideByZeroException dbzEx)
{
Console.WriteLine("Erreur : division par zéro.");
}
catch (Exception ex)
{
Console.WriteLine("Une autre exception a eu lieu : {0}.",
ex.Message);
}
finally
{
Console.WriteLine("Quel que soit le résultat, ceci est affiché.");
}
Pour cela, il faut dériver la classe Exception ou l'une de ses sous-classes. Par convention, toutes ces sous-
classes ont un nom se terminant par Exception.
Exemple :
Ensuite, cette classe peut être utilisée comme n'importe quelle autre classe d'exception. Donc dans le cas
d'erreur dans une méthode d'un programme (arguments invalides, ...), il est possible de lancer une notre
propre exception en utilisant le mot clé throw.
// Méthode 1
if ( arg==null )
throw new MyException();
// Méthode 2
if ( arg==null )
throw new MyException("Msg");