Compilation des connaissances de base C# : structure de classe des connaissances de base (3)

Nous avons défini les classes YSchool et YTeacher. Lors de l'instanciation d'un objet :

            YSchool shool1 = new YSchool();

            shool1.ID = 1;

            shool1.Name = "清华附中";

            YSchool school2 = new YSchool();

            school2.ID = 2;

            school2.Name = "北师大附中";

Est-ce correct ? En fait, c'est logiquement incorrect car lorsqu'un objet est instancié, ses propriétés doivent être fournies avec ? instanciation, plutôt que d’ajouter des attributs ultérieurement. La performance du programme est que les attributs doivent avoir des valeurs initiales.
Donc, il doit y avoir une telle méthode dans la classe, sans type de retour, le nom de la méthode est le même que le nom de la classe, et il doit y avoir une liste de classes de paramètres ou aucune liste de paramètres. Il s'agit de la méthode de construction, communément appelée « constructeur » ou « constructeur ». Une classe peut avoir un ou plusieurs constructeurs. Bien sûr, parfois vous n'écrivez pas de constructeur. Cela ne signifie pas que la classe n'a pas de constructeur. Si plusieurs constructeurs sont utilisés, leurs listes de paramètres respectives doivent être différentes.
Ce qui suit utilise YSchool comme exemple pour améliorer cette classe.

  /// <summary>
    /// YSchool类的id和name是它的固有属性，它的值应该是确定的。
    /// 实例化的同时对属性赋初值，用到构造函数。
    /// </summary>
    public class YSchool
    {
        private int id = 0;

        private string name = string.Empty;

        public int ID
        {
            get
            {
                return this.id;
            }
        }

        public string Name
        {
            get
            {
                return name;
            }
        }
        /// <summary>
        /// 没有参数的构造器称之为“默认构造器”；如果没有写一个构造器，那么
        ///系统也会提供一个默认的构造器，所以说类至少有一个构造器；
        ///当然，如果系统提供的默认构造函数，则属性初值为声明时赋的初值，如果声明
        ///未赋初值，则是“类型默认值”，比如0或者null。
        /// </summary>
        public YSchool()
        {
            this.id = 0;

            this.name = @"清华附中";
        }
        /// <summary>
        /// 带有参数列表的构造函数，
        /// 属性的值就是传入的列表的值。
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        public  YSchool(int id, string name)
        {
            this.id = id;

            this.name = name;
        }
        public  YSchool(int id)
        {
            this.id = id;

            this.name = @"陕科大附中";
        }
    }

   class Program
    {
        static void Main(string[] args)
        {
            YSchool shool1 = new YSchool();

            YSchool school2 = new YSchool(1, @"西工大附中");

            YSchool school3 = new YSchool(2);

            Console.ReadKey();
        }
    }

Les attributs get/set de id et name ont également été modifiés pour obtenir uniquement, car ces valeurs d'attribut sont des attributs inhérents, et il n'est pas logique d'attribuer des valeurs après instanciation. Autrement dit, ces propriétés sont en lecture seule.

La valeur par défaut est mentionnée dans le code, parlons-en brièvement ici. Lors de la déclaration d'un champ, vous pouvez utiliser l'opérateur d'affectation "=" pour ajouter directement une valeur au champ, telle que

    string name = string.Empty;

Il ne s'agit pas d'attribuer une valeur à une variable. La valeur par défaut est simplement une. sous forme. L'affectation réelle d'une variable est toujours dans le constructeur. Généralement, les codes standardisés exigent que les variables se voient attribuer des valeurs initiales lors de leur déclaration. S'il n'y a pas de champ attribué au cours de la vie, le compilateur ajoutera un code d'affectation pour attribuer au champ la valeur par défaut définie. En fait, peu importe si nous ajoutons ou non une valeur par défaut au champ, le champ a une valeur par défaut, mais si nous n'ajoutons pas artificiellement de valeur par défaut, la valeur par défaut du champ sera 0 ou nulle.
Une autre chose à noter ici est que le constructeur par défaut du système a été mentionné plus tôt, mais lorsque le constructeur est défini, le constructeur par défaut du système n'existe pas. Par conséquent, si dans certains cas, le constructeur par défaut et le constructeur avec paramètres sont utilisés, le constructeur par défaut doit être défini manuellement. Par exemple,

        public YSchool()
        {

        }

ou

        public YSchool()
        {
            this.id = 0;

            this.name = @"尚进";
        }

En résumé, l'expression canonique pour instancier une classe doit être : nom de classe nom d'instance = nouveau nom de classe (liste de paramètres du constructeur

Ce qui précède est la compilation des connaissances de base de C# : structure de classe des connaissances de base (3). Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !