À l’intérieur d’une classe, toute fonction membre peut accéder directement à tous les autres membres de cette même classe par leur nom.
Les modificateurs d’accès sont des préfixes facultatifs dans la déclaration des membres. Ils définissent si d’autres parties du programme peuvent accéder au membre concerné et s’écrivent avant le type ou le nom de la méthode.
Champs
modificateur-d'accès type nomChampMéthodes
modificateur-d'accès type-retour nomMéthode()
{
...corps de la méthode
}Cinq niveaux d’accès
privateprivépublicpublicprotectedprotégéinternalinterneprotected internalprotégé interne
Pour l’instant, les lecteurs n’ont qu’à apprendre private et public. Les autres seront abordés dans les cours suivants.
Tous les membres sont accessibles depuis l’intérieur de la classe, quel que soit leur modificateur.
Voici un exemple
class Robot
{
public string name;
int age;
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Langage du code : C# (cs)
Dans l’exemple ci-dessus, on voit que la méthode publique SayHello, les méthodes privées AgeUpdate et SayHi, le champ privé age et le champ public name peuvent tous s’accéder mutuellement du moment que le code se trouve à l’intérieur de la classe.
Attention : évitez les appels mutuels, ils provoquent des boucles infinies. Par exemple
class Robot
{
public string name;
int age;
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
SayHi();
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Langage du code : C# (cs)Ici, SayHi appelle SayHello, et SayHello appelle à nouveau SayHi. Ces appels croisés créent une récursivité sans fin.
Cela entraîne un plantage du programme
Un dépassement de mémoire est signalé
Par ailleurs, vous ne pouvez pas appeler directement des méthodes ordinaires lors de l’initialisation des champs, à moins que ces méthodes soient statiques. En effet, les méthodes membres classiques doivent être invoquées à travers une instance d’objet.
class Robot
{
public string name;
int age = GetInt();
static int GetInt()
{
return 1;
}
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Langage du code : C# (cs)Comme sur l’illustration, rendre la méthode statique résout le problème. Cependant, soyez vigilant : si la valeur renvoyée par GetInt varie lors de l’affectation de age
class Program
{
static void Main(string[] args)
{
Robot robot1 = new Robot();
for (int i = 0; i < 100; i++)
{
robot1.WriteAge();
System.Threading.Thread.Sleep(1000);
}
}
}
class Robot
{
public string name;
int age = GetInt();
static int GetInt()
{
return DateTime.Now.Second;
}
public void WriteAge()
{
Console.WriteLine($"I am {age} years old");
}
}Langage du code : C# (cs)Dans cet exemple, GetInt retourne la seconde actuelle de l’horloge. Dans Main, une boucle for exécute cent fois la fonction d’affichage de l’âge, avec une pause d’une seconde entre chaque affichage. On constate alors ceci :
La seconde affichée reste toujours celle récupérée au moment de l’initialisation. Lors de l’affectation de age, GetInt ne s’exécute qu’une seule fois. Si la valeur obtenue est par exemple 45, age conservera définitivement cette valeur, peu importe le nombre d’affichages ultérieurs. C’est ce que nous avons vu dans le chapitre précédent : la valeur initiale d’un champ doit être déterminée au moment de l’initialisation.
Revenons maintenant aux modificateurs d’accès
En résumé : tous les membres sont accessibles depuis l’intérieur de la classe, quel que soit leur modificateur d’accès.
private – Accès privé
Les membres privés ne sont accessibles qu’à l’intérieur de la classe où ils sont déclarés. Aucune autre classe ne peut les lire ou les modifier.
Le niveau d’accès par défaut des membres de classe est private. Omettre le modificateur équivaut à écrire explicitement private ; les deux syntaxes ont exactement la même signification.
int MyInt1; // privé implicite (défaut)
private int MyInt2; // privé expliciteLangage du code : C# (cs)public – Accès public
Les membres publics d’une instance sont accessibles par tous les autres objets du programme. Vous devez ajouter manuellement le modificateur public pour les déclarer.
public int MyInt; // marqué par le modificateur publicLangage du code : C# (cs)Règles de visibilité des membres
On utilise fréquemment des diagrammes de classes pour représenter les structures de classes
La classe entière est représentée par un cadre rectangulaire, les membres sont des zones à l’intérieur du cadre ;
Membres private : entièrement contenus dans le cadre de la classe, invisibles de l’extérieur ;
Membres public : une partie dépasse du cadre de la classe, ce qui signifie qu’ils sont accessibles globalement.
class Program
{
int Member1; // private implicite
private int Member2; // private explicite
public int Member3; // public
}Langage du code : C# (cs)
Exemple de ce chapitre
class C1
{
int F1; // champ privé implicite
private int F2; // champ privé explicite
public int F3; // champ public
void DoCalc() // méthode privée implicite
{
...
}
public int GetVal() // méthode public
{
...
}
}Langage du code : C# (cs)- Membres privés (F1, F2, DoCalc()) : seul le code de la classe
C1peut les lire, écrire et appeler ; ils sont totalement invisibles depuis les classes externes ; - Membres publics (F3, GetVal()) : accessibles sans restriction par n’importe quelle autre classe ou objet du programme ;
- Règle interne à la classe : toutes les méthodes de
C1, publiques ou privées, peuvent accéder à l’ensemble des champs et méthodes de cette même classe.
Exemple exécutable
class Program
{
static void Main(string[] args)
{
Worker worker = new Worker();
Console.WriteLine(worker.GetHours()); // Valide, on accède au membre public GetHours hors de la classe
Console.WriteLine(worker.ReadSavings());//Erreur : impossible d’accéder au membre privé ReadSavings hors de la classe, même via l’instance worker.
Console.WriteLine(worker.hours); // Valide, accès au champ public hours hors de la classe
Console.WriteLine(worker.savings); //Erreur : impossible d’accéder au champ privé savings hors de la classe
Console.WriteLine(worker.age); //Erreur : impossible d’accéder au champ privé age hors de la classe
}
}
class Worker
{
int age; // champ privé implicite
private double savings; // champ privé explicite
public int hours; // champ public
void ReadSavings() // méthode privée implicite
{
Console.WriteLine(savings);
}
public int GetHours() // méthode public
{
return hours;
}
}Langage du code : C# (cs)
Vous devriez maintenant avoir une compréhension de base des modificateurs d’accès.
Modificateurs d’accès