C# - Cours
Lorsque vous définissez une classe, vous définissez un plan pour un type de données. Cela ne définit en fait aucune donnée, mais définit ce que signifie le nom de la classe. Autrement dit, en quoi consiste un objet de la classe et quelles opérations peuvent être effectuées sur cet objet. Les objets sont des instances d'une classe. Les méthodes et les variables qui constituent une classe sont appelées membres de la classe.
Définir une classe
Une définition de classe commence par le mot clé class suivi du nom de la classe; et le corps de la classe entouré d'une paire d'accolades. Voici la forme générale d'une définition de classe −
<access specifier> class class_name {
// member variables
<access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// member methods
<access specifier> <return type> method1(parameter_list) {
// method body
}
<access specifier> <return type> method2(parameter_list) {
// method body
}
...
<access specifier> <return type> methodN(parameter_list) {
// method body
}
}
Remarque −
-
Les spécificateurs d'accès spécifient les règles d'accès pour les membres ainsi que la classe elle-même. S'il n'est pas mentionné, le spécificateur d'accès par défaut pour un type de classe est interne . L'accès par défaut pour les membres est privé .
-
Le type de données spécifie le type de variable et le type de retour spécifie le type de données des données renvoyées par la méthode, le cas échéant.
-
Pour accéder aux membres de la classe, vous utilisez l'opérateur point (.).
-
L'opérateur point relie le nom d'un objet au nom d'un membre.
L'exemple suivant illustre les concepts abordés jusqu'ici −
Démo en direct
using System;
namespace BoxApplication {
class Box {
public double length; // Length of a box
public double breadth; // Breadth of a box
public double height; // Height of a box
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 specification
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// volume of box 1
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Volume of Box1 : {0}", volume);
// volume of box 2
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Volume of Box1 : 210 Volume of Box2 : 1560
Fonctions membres et encapsulation
Une fonction membre d'une classe est une fonction qui a sa définition ou son prototype dans la définition de classe similaire à toute autre variable. Il opère sur n'importe quel objet de la classe dont il est membre et a accès à tous les membres d'une classe pour cet objet.
Les variables membres sont les attributs d'un objet (du point de vue de la conception) et elles sont gardées privées pour implémenter l'encapsulation. Ces variables ne sont accessibles qu'à l'aide des fonctions membres publiques.
Mettons ci-dessus des concepts pour définir et obtenir la valeur des différents membres de la classe dans une classe −
Démo en direct
using System;
namespace BoxApplication {
class Box {
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
public void setLength( double len ) {
length = len;
}
public void setBreadth( double bre ) {
breadth = bre;
}
public void setHeight( double hei ) {
height = hei;
}
public double getVolume() {
return length * breadth * height;
}
}
class Boxtester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box();
double volume;
// Declare Box2 of type Box
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}" ,volume);
// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Volume of Box1 : 210 Volume of Box2 : 1560
Constructeurs C#
Un constructeur de classe est une fonction membre spéciale d'une classe qui est exécutée chaque fois que nous créons de nouveaux objets de cette classe.
Un constructeur a exactement le même nom que celui de la classe et il n'a pas de type de retour. L'exemple suivant explique le concept de constructeur −
Démo en direct
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() {
Console.WriteLine("Object is being created");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Object is being created Length of line : 6
Un constructeur par défaut n'a pas de paramètre mais si vous en avez besoin, un constructeur peut avoir des paramètres. Ces constructeurs sont appelés constructeurs paramétrés . Cette technique vous aide à attribuer une valeur initiale à un objet au moment de sa création comme le montre l'exemple suivant −
Démo en direct
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line(double len) { //Parameterized constructor
Console.WriteLine("Object is being created, length = {0}", len);
length = len;
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line(10.0);
Console.WriteLine("Length of line : {0}", line.getLength());
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Object is being created, length = 10 Length of line : 10 Length of line : 6
Destructeurs C#
Un destructeur est une fonction membre spéciale d'une classe qui est exécutée chaque fois qu'un objet de sa classe sort de la portée. Un destructeur a exactement le même nom que celui de la classe avec un tilde préfixé (~) et elle ne peut ni renvoyer de valeur ni prendre de paramètres.
Le destructeur peut être très utile pour libérer des ressources mémoire avant de quitter le programme. Les destructeurs ne peuvent pas être hérités ou surchargés.
L'exemple suivant explique le concept de destructeur −
Démo en direct
using System;
namespace LineApplication {
class Line {
private double length; // Length of a line
public Line() { // constructor
Console.WriteLine("Object is being created");
}
~Line() { //destructor
Console.WriteLine("Object is being deleted");
}
public void setLength( double len ) {
length = len;
}
public double getLength() {
return length;
}
static void Main(string[] args) {
Line line = new Line();
// set line length
line.setLength(6.0);
Console.WriteLine("Length of line : {0}", line.getLength());
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Object is being created Length of line : 6 Object is being deleted
Membres statiques d'une classe C#
Nous pouvons définir les membres de classe comme statiques en utilisant le static mot-clé. Lorsque nous déclarons un membre d'une classe comme statique, cela signifie que peu importe le nombre d'objets de la classe créés, il n'y a qu'une seule copie du membre statique.
Le mot-clé statique implique qu'une seule instance du membre existe pour une classe. Les variables statiques sont utilisées pour définir des constantes car leurs valeurs peuvent être récupérées en appelant la classe sans en créer une instance. Les variables statiques peuvent être initialisées en dehors de la fonction membre ou de la définition de classe. Vous pouvez également initialiser des variables statiques dans la définition de classe.
L'exemple suivant illustre l'utilisation de variables statiques −
Démo en direct
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public int getNum() {
return num;
}
}
class StaticTester {
static void Main(string[] args) {
StaticVar s1 = new StaticVar();
StaticVar s2 = new StaticVar();
s1.count();
s1.count();
s1.count();
s2.count();
s2.count();
s2.count();
Console.WriteLine("Variable num for s1: {0}", s1.getNum());
Console.WriteLine("Variable num for s2: {0}", s2.getNum());
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Variable num for s1: 6 Variable num for s2: 6
Vous pouvez également déclarer une fonction membre comme statique . Ces fonctions ne peuvent accéder qu'aux variables statiques. Les fonctions statiques existent avant même la création de l'objet. L'exemple suivant illustre l'utilisation de fonctions statiques −
Démo en direct
using System;
namespace StaticVarApplication {
class StaticVar {
public static int num;
public void count() {
num++;
}
public static int getNum() {
return num;
}
}
class StaticTester {
static void Main(string[] args) {
StaticVar s = new StaticVar();
s.count();
s.count();
s.count();
Console.WriteLine("Variable num: {0}", StaticVar.getNum());
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −
Variable num: 3
Langue C