[Tutoriel c#] Classe C# (Classe)

Classe C# (Class)

Lorsque vous définissez une classe, vous définissez un modèle d'un type de données. Cela ne définit en réalité aucune donnée, mais cela définit ce que signifie le nom de la classe, c'est-à-dire en quoi consiste un objet de la classe et quelles opérations peuvent être effectuées sur cet objet. Les objets sont des instances de classes. Les méthodes et variables qui composent une classe deviennent membres de la classe.

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

Veuillez noter :

Le spécificateur d'accès 2903cec133a2d98347f30d0ba5e3ee4a 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 une classe est interne et pour les membres est privé.

Type de données 404d4d325bd1451e8bdb1d68a7b7e969 spécifie le type de la variable, type de retour ba3d0ac670650f02ea2073f3c915c398 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

Membre 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 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 le 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

La valeur par défaut le constructeur ne prend 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 d'une 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 le concept 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 est compilé et exécuté, il produit les résultats suivants :

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

Membres statiques des classes C#

Nous pouvons utiliser le mot-clé static pour définir 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.

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。您也可以在类的定义内部初始化静态变量。

下面的实例演示了静态变量的用法：

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();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

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

您也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。下面的实例演示了静态函数的用法：

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();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

变量 num： 3

 以上就是【c#教程】C# 类（Class）的内容，更多相关内容请关注PHP中文网（www.php.cn）！