Explication détaillée de la méthode de construction et exemple de code de la classe C#

Cet article présente principalement la méthode constructeur de la classe c#. Il a une certaine valeur de référence, jetons-y un œil avec l'éditeur ci-dessous

1 Méthode de construction

La méthode de construction d'une classe est le membre. méthode de la classe, sa fonction est d'initialiser les membres de la classe. Les méthodes de construction de la classe sont divisées en :

1. statique méthode de construction

2. Méthode de construction d'instance

1. Méthode de construction statique

La méthode de construction statique d'une classe est un type de méthode membre de la classe, et sa fonction est Initialiser les membres statiques de la classe. Veuillez consulter l'exemple de code ci-dessous :

using System;
namespace LycheeTest {
 class Test {
 //定义一个静态成员变量
 private static int a;
 //定义静态构造函数
 static Test() {
  //初始化静态成员变量
  a = 11;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
 }
 }
 class Program {
 static void Main(string[] args) {
  Test t = new Test();
  t.Show();
  Console.ReadKey();
 }
 }
}

Tout d'abord, le code ci-dessus définit deux classes. La ligne 3 définit la classe Test. Lors de la définition d'une classe, il existe deux modificateurs d'autorisation d'accès pour la classe, l'un est public et l'autre interne. Lorsqu'aucun modificateur d'accès n'est écrit, l'autorisation d'accès de la classe est interne par défaut. La signification de cette autorisation d'accès est que cette classe n'est accessible que par cet assembly et ne peut pas être consultée par les classes extérieures à cet assembly. Si cette classe appartient à une

Bibliothèque de classes, alors elle doit être publique, sinon l'assembly qui l'appelle ne peut pas y accéder. La ligne 5 du code définit un membre de champ statique et la ligne 7 du code est le constructeur statique. Comme vous pouvez le voir, la caractéristique de la méthode de construction statique est que le mot-clé static indique que la méthode est statique et que le nom de la méthode doit être exactement le même que le nom de la classe. Faites attention à la casse ici. Les méthodes de construction statiques ne peuvent pas contenir de paramètres et les méthodes de construction statiques ne peuvent pas avoir de valeurs de retour. Vous pouvez initialiser les membres statiques dans le corps de la méthode constructeur statique. La ligne 11 définit une méthode d'instance qui génère la valeur d'un champ statique. Cette classe est appelée dans la méthode Main (note : main en Java) dans la classe Program à la ligne 16, une instance de cette classe est créée à la ligne 18, et la méthode d'instance de la classe est appelée à la ligne 19.

Comme vous pouvez le voir dans le code ci-dessus, le constructeur statique de la classe n'est pas explicitement appelé.

Veuillez voir le résultat de l'exécution du code ci-dessus ci-dessous :

静态字段 a 的值是：11

Comme vous pouvez le voir, la méthode de construction statique est bien exécutée. Ensuite, l'exemple ci-dessus est l'une des conditions d'exécution de la méthode de construction statique. Lorsqu'une instance de la classe est créée, la méthode de construction statique de la classe sera automatiquement appelée.

L'ordre d'appel du constructeur statique est après l'initialiseur du champ statique.

C'est-à-dire que la première étape consiste à définir la valeur par défaut du champ statique, la deuxième étape consiste à exécuter le paramètre de définition de valeur initiale du champ statique et la troisième étape consiste à appeler la méthode du constructeur statique de la classe.

Modifions l'exemple de code précédent. Le code est le suivant :

using System;
namespace LycheeTest{
 class Test {
 private static int a;
 static Test() {
  a++;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  14
 }
 }
 class Program {
 static void Main(string[] args) {
  Test t = new Test();
  t.Show();
  Test t1 = new Test();
  t.Show();
  Console.ReadKey();
 }
 }
}

Ce code modifie la méthode de construction statique et incrémente le champ statique a dans le corps de la méthode. Ensuite, à la ligne 17 du code, une autre instance de la classe est créée et la méthode d'instance de la classe est à nouveau appelée.

Regardez les résultats d'exécution ci-dessous :

静态字段 a 的值是：1 
静态字段 a 的值是：1

Comme vous pouvez le constater, la valeur du champ statique n'a pas augmenté. C'est la caractéristique de l'exécution d'un constructeur statique, il n'est exécuté qu'une seule fois. Lorsque l'assembly est exécuté, un domaine d'application sera créé. Dans un domaine d'application, la méthode de construction statique de la classe n'est exécutée qu'une seule fois.

L'exemple de code est modifié comme suit :

using System;
namespace LycheeTest {
 class Test {
 public static int a;
 static Test() {
  Console.WriteLine("类的静态构造方法开始执行");
  a++;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
 }
 }
 class Program {
 static void Main(string[] args) {
  Console.WriteLine("静态字段 a 的值是：{0}", Test.a);
  Console.WriteLine("静态字段 a 的值是：{0}", Test.a);
  Console.ReadKey();
 }
 }
}

Ce code imprime une ligne de balises dans la méthode de construction statique de la classe, et les autorisations d'accès aux champs statiques de la classe. class sont également modifiés en public, ce qui le rend appelable en dehors de la classe. La valeur du champ statique est imprimée deux fois dans la méthode Main. Notez que l'appel du champ statique de la classe en dehors de la classe nécessite d'utiliser le nom de la classe pour

référence.

Ce qui suit est le résultat de l'exécution du code :

类的静态构造方法开始执行
静态字段 a 的值是：1
静态字段 a 的值是：1

Ce code ne crée pas d'instance de la classe. Avant de référencer les membres statiques de la classe, le constructeur statique de la classe sera appelé. Les membres statiques de la classe appelée incluent des champs statiques et des méthodes statiques. C'est la deuxième condition pour appeler la méthode constructeur statique de la classe.

L'exemple de code est modifié comme suit :

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 static void Main(string[] args) {
  Console.WriteLine("Main 方法被调用");
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  Console.ReadKey();
 }
 }
}

Ce code définit les champs statiques et les constructeurs statiques dans la classe contenant la méthode Main. Parce que la méthode Main est également une méthode statique, le constructeur statique de la classe est appelé et c'est la méthode du point d'entrée de la classe, alors qui l'appelle en premier entre lui et le constructeur statique de la classe ? Examinons d'abord les résultats d'exécution du code :

类的静态构造方法被调用
Main 方法被调用
静态字段 a 的值是：11

Vous pouvez voir dans les résultats d'exécution du code que, parce que la méthode du point d'entrée de la classe est toujours une méthode statique, avant que des membres statiques ne soient appelée, les méthodes de construction statiques sont appelées en premier. Par conséquent, on peut conclure que le constructeur statique de la classe est appelé avant la méthode Main de la classe.

Alors le constructeur statique d'une classe peut-il être appelé explicitement ? Regardez l'exemple de code ci-dessous :

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 static void Main(string[] args) {
  Program();
  Console.ReadKey();
 }
 }
}

在这段代码中的第 10 行显式调用了类的静态构造方法，这时编译器会报错。

2.实例构造函数

类的实例构造方法是类的成员方法的一种，它的作用是对类的实例成员进行初始化操作。实例构造方法可以实现重载，在创建类的实例时，可以显式的指定不同的参数来调用重载的不同的实例构造方法。下面请看代码实例：

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 private int b = 12;
 private string c = "Hello World";
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 public Program(int a, string s) {
  Console.WriteLine("带二个参数的构造方法被调用");
  this.b = a;
  this.c = s;
 }
 public Program(int a) : this(a, "通过 this 关键字调用构造方法") {
  Console.WriteLine("带一个参数的构造方法被调用");
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  Console.WriteLine("实例字段 b 的值是：{0}", b);
  Console.WriteLine("实例字段 c 的值是：{0}", c);
 }
 static void Main(string[] args) {
  Program p1 = new Program(33, "这是创建的实例 P1");
  Program p2 = new Program(34);
  p1.Show();
  p2.Show();
  Console.ReadKey();
 }
 }

这段代码的第 4 行、第 5 行和第 6 行分别定义了三个字段成员，第 4 行是静态字段，第 5 行和第 6 行代码都有初始值设定项。代码的第 8 行就是一个实例构造方法的定义，实例构造方法也是以类名作为方法名，它没有返回值， 在方法名前面是访问权限修饰符，可以使用的访问权限修饰符包括 public、private 和 protected。其中的 protected 意味着构造方法只能在此类内部访问。实例构造方法可以带参数。 第 12 行代码的实例构造方法使用两个传入的参数对实例字段进行了赋值。第 17 行代码定义了带一个参数的实例构造方法，它和前一个实例构造方法形成了重载。实例构造方法可以通过 this 关键字调用其他的实例构造方法，方法就是在参数列表的后面使用冒号然后接 this 关键字， 然后再跟参数列表，这个参数列表要匹配另一个重载的实例构造方法。第 17 行的构造方法只有一个参数， 它将这个参数通过 this 关键字传递给了另一个构造方法，在用 this 调用另一个构造方法的时候，为其同时传入了一个字符串参数。第 24 行的实例方法打印类的字段成员的值。在 Main 方法中，第 26 行代码和第 27 行代码分别定义了两个实例，它们使用 new 关键字调用了不同的实例构造方法。第 28 行和第 29 行分别调用实例方法打印类的静态字段和实例的两个字段成员的值。

下面先来看代码的执行结果：

类的静态构造方法被调用 带二个参数的构造方法被调用 带二个参数的构造方法被调用 带一个参数的构造方法被调用 
静态字段 a 的值是：11 
实例字段 b 的值是：33
实例字段 c 的值是：这是创建的实例 P1 静态字段 a 的值是：11
实例字段 b 的值是：34
实例字段 c 的值是：通过 this 关键字调用构造方法

现在用执行结果来介绍实例构造方法的执行过程，当第 26 行代码创建类的实例时，类的静态字段首先被设置成默认值，因为没有字段的初始值设定项，所以接着就执行类的静态构造方法。这时静态字段 a 被 设置成 11。因为第 26 行代码使用 new 调用了带有两个参数的实例构造方法，所以首先实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接 下来执行实例构造方法体中的第一个语句，“带二个参数的构造方法被调用”这个字符串被打印。接下来 实例 p1 的字段 b 被设置为传入的参数 33，注意构造方法的形参 a 在这里覆盖了类的静态字段 a。也就是说， 这时起作用的是实例构造方法的局部变量 a。然后实例字段 c 被设置为字符串"这是创建的实例 P1"。第 27 行代码使用 new 关键字调用了带一个参数的实例构造方法，在调用时，首先属于 p2 的实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接下来执行的是 this 引用的带两个参数的实例构造方法，"带二个参数的构造方法被调用"这个 字符串被打印。然后 b 被设置为 34，c 被设置为"通过 this 关键字调用构造方法"。最后，代码控制又返回 来执行带一个参数的实例构造方法体中的打印语句，"带一个参数的构造方法被调用"这个字符串被打印。 至此，实例构造方法的执行完毕。接下来的代码打印静态字段的值，可以看到两个实例打印出来的静态字段值是一样的，但是它们的实 例字段的值各不相同。

可选参数和命名参数也可以用于实例构造方法，下面看代码实例：

using System;
namespace LycheeTest {
 class Program {
 private int b;
 private string c;
 public Program(int a = 12, string s = "") {
  this.b = a;
  this.c = s;
 }
 public void Show() {
  Console.WriteLine("实例字段 b 的值是：{0}", b);
  Console.WriteLine("实例字段 c 的值是：{0}", c);
 }
 static void Main(string[] args) {
  Program p1 = new Program(); //构造方法的两个参数都采用默认值
  Program p2 = new Program(34); //构造方法的 string 类型参数采用默认值
  Program p3 = new Program(23, "Hello World"); //构造方法的两个参数采用传入参数
  Program p4 = new Program(s: "今天的天气真好"); //采用命名参数，另一个参数 a 采用默认值
  p1.Show();
  p2.Show();
  p3.Show();
  p4.Show();
  Console.ReadKey();
 }
 }
}

代码的第 6 行定义了一个带有可选参数和命名参数的构造方法，然后第 15 创建了一个类的实例，在构造方法中没有传入任何参数，这时，构造方法的两个参数都采用默认值。第 16 行代码为构造方法传入了一个 int 类型的参数，这时，另一个 string 类型的参数采用默认值。 第 17 行代码传入了两个参数，构造方法的两个参数都使用了这两个传入的参数。第 18 行代码使用了命名参数指定传入的参数是 string 类型的参数，并将它传递给形参 s。这时另一 个 int 类型的参数采用默认值。第 19 行到第 23 行代码打印类的实例字段的值。这段代码的执行结果如下：

实例字段 b 的值是：12 
实例字段 c 的值是： 
实例字段 b 的值是：34 
实例字段 c 的值是： 
实例字段 b 的值是：23
实例字段 c 的值是：Hello World 实例字段 b 的值是：12
实例字段 c 的值是：今天的天气真好

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!