C # - Classes

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 variables qui constituent une classe sont appelées membres de la classe.

Définition d'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é 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. S'il n'est pas mentionné, le spécificateur d'accès par défaut pour un type de classe estinternal. L'accès par défaut pour les membres estprivate.

  • 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 lie le nom d'un objet au nom d'un membre.

L'exemple suivant illustre les concepts discutés jusqu'à présent -

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 des membres et encapsulation

Une fonction membre d'une classe est une fonction dont la définition ou son prototype dans la définition de classe est 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 -

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 constructor 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 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

UNE default constructorn'a aucun paramètre mais si vous en avez besoin, un constructeur peut avoir des paramètres. Ces constructeurs sont appelésparameterized constructors. Cette technique vous aide à attribuer une valeur initiale à un objet au moment de sa création, comme illustré 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

Destructeurs C #

UNE destructorest une fonction membre spéciale d'une classe qui est exécutée chaque fois qu'un objet de sa classe est hors de portée. UNEdestructor a exactement le même nom que celui de la classe avec un tilde préfixé (~) et il ne peut ni renvoyer une valeur ni prendre de paramètres.

Destructor 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 la classe comme statiques en utilisant le staticmot-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é staticimplique 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 montre l'utilisation de static variables -

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 un member function comme static. 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 montre l'utilisation destatic functions -

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