Zusammenstellung von C#-Grundkenntnissen: Grundwissen (3) Klassenstruktur

Wir haben die Klassen YSchool und YTeacher beim Instanziieren eines Objekts definiert:

            YSchool shool1 = new YSchool();

            shool1.ID = 1;

            shool1.Name = "清华附中";

            YSchool school2 = new YSchool();

            school2.ID = 2;

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

Ist das tatsächlich logisch falsch, denn wenn ein Objekt instanziiert wird, sollten seine Eigenschaften mitgeliefert werden Instanziierung, anstatt später Attribute hinzuzufügen. Die Leistung im Programm besteht darin, dass die Attribute Anfangswerte haben müssen.
Es muss also eine solche Methode in der Klasse geben, die keinen Rückgabetyp hat, der Methodenname mit dem Klassennamen übereinstimmt und es eine Parameterklassenliste oder keine Parameterliste gibt. Es ist die Konstruktionsmethode, die allgemein als „Konstruktor“ oder „Konstruktor“ bekannt ist. Eine Klasse kann einen oder mehrere Konstruktoren haben. Natürlich bedeutet dies nicht, dass die Klasse keinen Konstruktor hat. Wenn mehrere Konstruktoren verwendet werden, müssen ihre jeweiligen Parameterlisten unterschiedlich sein.
Im Folgenden wird YSchool als Beispiel zur Verbesserung dieser Klasse verwendet.

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

Die get/set-Attribute von id und name wurden ebenfalls auf nur get geändert, da diese Attributwerte inhärente Attribute sind und es nicht logisch ist, Werte danach zuzuweisen Instanziierung. Das heißt, diese Eigenschaften sind schreibgeschützt.

Der Standardwert wird im Code erwähnt, lassen Sie uns hier kurz darüber sprechen. Wenn Sie ein Feld deklarieren, können Sie den Zuweisungsoperator „=" verwenden, um dem Feld direkt einen Wert hinzuzufügen, z. B.

    string name = string.Empty;

Dabei wird einer Variablen kein Wert zugewiesen. Der Standardwert ist nur ein Die eigentliche Zuweisung einer Variablen befindet sich noch im Konstruktor. Im Allgemeinen erfordern Standardcodes, dass Variablen bei der Deklaration Anfangswerte zugewiesen werden. Wenn während der Lebensdauer kein Feld zugewiesen ist, fügt der Compiler einen Zuweisungscode hinzu, um das Feld dem festgelegten Standardwert zuzuweisen. Unabhängig davon, ob wir dem Feld einen Standardwert hinzufügen, hat das Feld tatsächlich einen Standardwert. Wenn wir jedoch keinen Standardwert künstlich hinzufügen, ist der Standardwert des Felds 0 oder null.
Hier ist noch zu beachten, dass der Systemstandardkonstruktor bereits erwähnt wurde, aber wenn der Konstruktor definiert ist, existiert der Systemstandardkonstruktor nicht. Wenn daher in einigen Fällen sowohl der Standardkonstruktor als auch der Konstruktor mit Parametern verwendet werden, muss der Standardkonstruktor manuell definiert werden. Zum Beispiel

        public YSchool()
        {

        }

oder

        public YSchool()
        {
            this.id = 0;

            this.name = @"尚进";
        }

Zusammenfassend sollte der kanonische Ausdruck zum Instanziieren einer Klasse lauten: Klassenname Instanzname = neuer Klassenname (Konstruktorparameterliste