Déclaration des propriétés (méthodes) C#

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 :

public class Client {
//Declaration des attributs

private int num ; private string nom ;
private double chiffre_affaire ;

//Implementation des methodes

public void modifierNom(string n){ nom=n ;
}
}

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 :

• • Pour connaitre la valeur de la propriété (un accesseur ou un getter).
  • Pour modifier la valeur de la propriété (un mutateur ou un setter).

Les accesseurs (getters) :

Ces méthodes sont appelées des méthodes de type Get, cette méthode ne prend pas de paramètre et retourne la valeur de l’attribut associé. Par exemple pour l’attribut num de type int, la fonction Get serait déclaré comme suit :

public int GetNum(){ Return this.num ;
}

Cette fonction pourra être utilisée dans la fonction main comme suit :

Client c = new Client() ;

int numero = c.num ; // faux , car l’attribut num est private

int numero = c.GetNum() ;// OK

Les mutateurs (setters):

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 :

public void SetNum(int numero){ this.num=numero;
}

Cette fonction pourra être utilisée dans la fonction main comme suit :

Client c = new Client() ;

c.num=5 ; // faux, car l’attribut num est private

c.SetNum(5); // OK

Jusqu’à présent, les propriétés déclarées sont que propriétés d’instance. C'est-à-dire que les propriétés de chaque objet, instancié à partir de la même classe, peuvent avoir des valeurs différentes.

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 par défaut
public Client(){ compteur+=1 ;
}

//Constructeur d’initialisation
public Client(int num, string nom, double ca){ compteur+=1 ;
This.num=num ; This.nom=nom ; This.ca=ca ;
}
}

Une méthode statique est une méthode qui peut être appelée même sans avoir instancié la classe. Une méthode statique ne peut accéder qu'à des attributs et méthodes statiques.

Méthode GetCompteur associée à la propriété compteur de classe client.

public static int GetCompteur(){ return compteur ;
}

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.

public static void Main(string[]args){ Client cli=new Client(5,"Said" , 21000);
int a= cli.GetCompteur(); //Faux GetCompteur est une méthode statique int a=Client.GetCompteur() ;//OK
}