Classe C#

Définition de classe

La définition d'une classe commence par le mot-clé class, suivi du nom de la classe. 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 :

• L'identifiant d'accès <access specifier> . S’il n’est pas spécifié, l’identifiant d’accès par défaut est utilisé. L'identifiant d'accès par défaut pour les classes est interne et pour les membres est privé.

• Type de données <type de données> spécifie le type de la variable, type de retour <type de retour> spécifie le type de données renvoyé par la méthode renvoyée.

• Si vous souhaitez accéder aux membres d'une classe, vous souhaitez utiliser l'opérateur point (.).

• L'opérateur point relie le nom de l'objet et le nom du membre.

L'exemple suivant illustre les concepts abordés jusqu'à présent :

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Box1 的体积： 210
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 la classe, tout comme les autres variables. En tant que membre d'une classe, il peut opérer sur n'importe quel objet de la classe et accéder à tous les membres de la classe de l'objet.

Les variables membres sont des propriétés de l'objet (du point de vue de la conception) et elles restent privées pour réaliser l'encapsulation. Ces variables ne sont accessibles qu’à l’aide des fonctions membres publiques.

Utilisons les concepts ci-dessus pour définir et obtenir les valeurs des différents membres de classe dans une classe :

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // 长度
       private double breadth;  // 宽度
       private double height;   // 高度
       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();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();		 // 声明 Box2，类型为 Box
            double volume;				 // 体积


            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}" ,volume);

            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
           
            Console.ReadKey();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

Box1 的体积： 210
Box2 的体积： 1560

Constructeur en C#

Le constructeur d'une classe est une fonction membre spéciale de la classe qui est exécutée lorsqu'un nouvel objet de la classe est créé.

Le nom du constructeur est exactement le même que le nom de la classe, il n'a aucun type de retour.

L'exemple suivant illustre le concept de constructeur :

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()
      {
         Console.WriteLine("对象已创建");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();    
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

对象已创建
线条的长度： 6

Par défaut Le constructeur de n’a aucun paramètre. Mais si vous avez besoin d'un constructeur avec des paramètres pouvant avoir des paramètres, ce type de constructeur est appelé constructeur paramétré. Cette technique peut vous aider à attribuer des valeurs initiales aux objets lors de leur création. Veuillez consulter l'exemple suivant pour plus de détails :

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line(double len)  // 参数化构造函数
      {
         Console.WriteLine("对象已创建，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("线条的长度： {0}", line.getLength()); 
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

对象已创建，length = 10
线条的长度： 10
线条的长度： 6

Destructeur en C#

Le destructeur de classe est une fonction membre spéciale de la classe qui est exécutée lorsque l'objet de la classe sort de la portée.

Le nom du destructeur est préfixé d'un tilde (~) avant le nom de la classe. Il ne renvoie pas de valeur et ne prend aucun paramètre.

Le destructeur est utilisé pour libérer des ressources avant de terminer le programme (comme fermer des fichiers, libérer de la mémoire, etc.). Les destructeurs ne peuvent pas être hérités ou surchargés.

L'exemple suivant illustre la notion de destructeur :

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()  // 构造函数
      {
         Console.WriteLine("对象已创建");
      }
      ~Line() //析构函数
      {
         Console.WriteLine("对象已删除");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());           
      }
   }
}

Lorsque le code ci-dessus sera compilé et exécuté, il produira les résultats suivants :

对象已创建
线条的长度： 6
对象已删除

Membres statiques des classes C#

Nous pouvons utiliser le mot-clé static Définissez les membres de la classe comme statiques. Lorsque nous déclarons un membre de classe comme statique, cela signifie que quel que soit le nombre d'objets de la classe créés, il n'y aura qu'une seule copie du membre statique.

Mot clé static signifie qu'il n'y a qu'une seule instance de ce membre dans la classe. Les variables statiques sont utilisées pour définir des constantes car leurs valeurs peuvent être obtenues en appelant directement la classe sans créer d'instance de la classe. Les variables statiques peuvent être initialisées en dehors d’une fonction membre ou d’une définition de classe. Vous pouvez également initialiser des variables statiques dans la définition d'une classe.

L'exemple suivant montre l'utilisation de la variable statique :

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("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

s1 的变量 num： 6
s2 的变量 num： 6

Vous pouvez également déclarer une fonction membre comme statique. De telles fonctions ne peuvent accéder qu'à des variables statiques. Les fonctions statiques existent avant la création de l'objet. L'exemple suivant démontre l'utilisation de la fonction statique :

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("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

变量 num： 3