Les classes dans C#
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 il définit ce que signifie le nom de la classe. C’est-à-dire quel est l’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.
Sommaire
Définir une classe
Une définition de classe commence par la classe de mots clés suivie du nom de la classe; Et le corps de classe entouré par 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. Si ce n’est pas mentionné, le spécificateur d’accès par défaut pour un type de classe est internal (interne). L’accès par défaut pour les membres est private (privée).
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 que la méthode renvoie, le cas échéant.
Pour accéder aux membres de la classe, vous utilisez l’opérateur point (.).
L’opérateur de points relie le nom d’un objet au nom d’un membre.
L’exemple suivant illustre les concepts discutés jusqu’ici:
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 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 fonctionne 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 des membres sont les attributs d’un objet (du point de vue de la conception) et sont conservées privées pour implémenter l’encapsulation. Ces variables ne peuvent être accessibles qu’avec les fonctions des membres publics.
Laissez-nous mettre des concepts ci-dessus pour définir et obtenir la valeur de différents membres de classe dans une classe:
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 #
Une classe constructeur est une fonction de membre spécial 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 aucun type de retour. L’exemple suivant explique le concept de constructeur:
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 aucun paramètre, mais si vous avez besoin, un constructeur peut avoir des paramètres. De tels constructeurs sont appelés constructeurs paramétrés. Cette technique vous aide à attribuer la valeur initiale à un objet au moment de sa création, comme indiqué dans l’exemple suivant:
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
C # Destructeurs
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 il ne peut ni retourner une valeur, ni ne peut prendre de paramètres.
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:
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 mot-clé statique. Lorsque nous déclarons un membre d’une classe comme statique, cela signifie 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 invoquant la classe sans créer une instance de celle-ci. Les variables statiques peuvent être initialisées en dehors de la fonction membre ou de la définition de classe. Vous pouvez également initialiser les variables statiques dans la définition de la classe.
L’exemple suivant démontre l’utilisation de variables statiques:
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. De telles fonctions ne peuvent accéder qu’aux variables statiques. Les fonctions statiques existent avant même que l’objet ne soit créé. L’exemple suivant illustre l’utilisation de fonctions statiques:
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
