C# Classe

Lorsque vous définissez une classe, vous définissez un plan pour un type de données. Cela ne définit pas réellement de données, mais cela définit ce que le nom de la classe signifie, c'est-à-dire de quoi les objets de la classe sont constitués et quelles opérations peuvent être effectuées sur cet objet. Les objets sont des instances de la classe. Les méthodes et les variables qui composent une classe sont appelées membres de la classe.

Définition de classe

La définition d'une classe commence par le mot-cléclassCommencez, suivi du nom de la classe. Le corps de la classe, entouré d'une paire d'accolades. Ce qui suit est la forme générale d'une définition de classe :

<spécificateur d'accès> class  class_name
{
    // variables membres
    <spécificateur d'accès> <type de données> variable1;
    <spécificateur d'accès> <type de données> variable2;
    ...
    <spécificateur d'accès> <type de données> variableN;
    // méthodes membres
    <spécificateur d'accès> <type de retour> method1(parameter_list)
    {
        // corps de méthode
    }
    <spécificateur d'accès> <type de retour> method2(parameter_list)
    {
        // corps de méthode
    }
    ...
    <spécificateur d'accès> <type de retour> methodN(parameter_list)
    {
        // corps de méthode
    }
}

Veuillez noter :

  • Le spécificateur d'accès <spécificateur d'accès> spécifie les règles d'accès pour la classe et ses membres. S'il n'est pas spécifié, le spécificateur d'accès par défaut est utilisé. Le spécificateur d'accès par défaut pour une classe estinternal, et l'identificateur d'accès par défaut pour les membres estprivate。
  • Le type de données <type de données> spécifie le type d'une variable, et le type de retour <type de retour> spécifie le type de données renvoyé par la méthode.
  • Pour accéder à un membre d'une classe, vous utilisez 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 :

Exemple

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // Longueur
       public double breadth;  // Largeur
       public double height;   // Hauteur
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // Déclarer Box1 de type Box
            Box Box2 = new Box();        // Déclarer Box2 de type Box
            double volume = 0.0;         // volume

            // Détails de Box1
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Détails de Box2
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Volume de Box1
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volume de Box1: {0}", volume);

            // Volume de Box2
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volume de 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 dont la définition ou le prototype se situe dans la définition de la classe, tout comme les autres variables. En tant que membre de la classe, elle peut opérer sur n'importe quel objet de la classe et peut accéder à tous les membres de la classe de cet objet.

Les variables membres sont des attributs d'un objet (du point de vue de la conception), et elles restent privées pour assurer l'encapsulation. Ces variables ne sont accessibles qu'en utilisant des fonctions membres publiques.

Utilisons les concepts ci-dessus pour définir et récupérer les valeurs de différents membres d'une classe :

Exemple

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // Longueur
       private double breadth;  // Largeur
       private double height;   // Hauteur
       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();        // Déclarer Box1 de type Box
            Box Box2 = new Box();        // Déclarer Box2 de type Box
            double volume;               // volume


            // Détails de Box1
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Détails de Box2
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Volume de Box1
            volume = Box1.getVolume();
            Console.WriteLine("Volume de Box1 : {0}" ,volume);

            // Volume de Box2
            volume = Box2.getVolume();
            Console.WriteLine("Volume de 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

Constructeurs en C#

ClasseConstructeurIl s'agit d'une fonction membre spéciale d'une 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, et il n'a aucun type de retour.

L'exemple suivant illustre le concept de constructeur :

Exemple

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Longueur de la ligne
      public Line()
      {
         Console.WriteLine("Objet créé");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();    
         // Définir la longueur de la ligne
         line.setLength(6.0);
         Console.WriteLine("La longueur de la ligne : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

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

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

Constructeur par défautIl ne possède aucun paramètre. Mais si vous avez besoin d'un constructeur avec paramètres, il peut avoir des paramètres ; ce type de constructeur est appeléConstructeur paramétré. Cette technique peut vous aider à attribuer des valeurs initiales aux objets au moment de leur création. Voir l'exemple suivant pour plus de détails :

Exemple


using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Longueur de la ligne
      public Line(double len)  // Constructeur paramétré
      {
         Console.WriteLine("Objet créé, longueur = {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("La longueur de la ligne : {0}", line.getLength());
         // Définir la longueur de la ligne
         line.setLength(6.0);
         Console.WriteLine("La longueur de la ligne : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

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

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

Destructeurs en C#

ClassedestructeurIl s'agit d'une fonction membre spéciale d'une classe qui est exécutée lorsqu'un objet de la classe sort de sa portée.

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

Un destructeur est utilisé pour libérer des ressources avant la fin d'un programme (comme fermer des fichiers, libérer de la mémoire, etc.). Les destructeurs ne peuvent pas être hérités ni surchargés.

L'exemple suivant illustre le concept de destructeur :

Exemple


using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Longueur de la ligne
      public Line()  // constructeur
      {
         Console.WriteLine("Objet créé");
      }
      ~Line() //Destructeur
      {
         Console.WriteLine("Objet supprimé");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();
         // Définir la longueur de la ligne
         line.setLength(6.0);
         Console.WriteLine("La longueur de la ligne : {0}", line.getLength());          
      }
   }
}

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

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

Membres statiques d'une classe C#

Nous pouvons utiliserstaticLe mot-clé définit un membre de classe comme statique. 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'existe qu'une seule copie de ce membre statique.

Mots-clésstaticSignifie 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 des fonctions membres ou de la définition de la classe. Vous pouvez également initialiser des variables statiques dans la définition de la classe.

L'exemple suivant démontreVariable statiqueUtilisation :

Exemple

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 de s1 : {0}", s1.getNum());
            Console.WriteLine("variable num de s2 : {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

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

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

Vous pouvez également mettre uneFonction membredéclarée commestatic. De telles fonctions ne peuvent accéder qu'aux variables statiques. Les fonctions statiques existent déjà avant la création des objets. L'exemple suivant démontreFonctions statiquesUtilisation :

Exemple

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 les résultats suivants :

变量 num： 3
autres extensions