C# basic knowledge compilation: basic knowledge (3) class structure

We have defined the YSchool and YTeacher classes. When instantiating the object:

            YSchool shool1 = new YSchool();

            shool1.ID = 1;

            shool1.Name = "清华附中";

            YSchool school2 = new YSchool();

            school2.ID = 2;

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

Is this correct? In fact, it is logically incorrect, because when the object is instantiated, its attributes should be and It is there at the time of instantiation, rather than adding attributes later. The performance in the program is that the attributes must have initial values.
So, there must be such a method in the class, with no return type, the method name is the same as the class name, and there is a parameter class table or no parameter list. It is the construction method, commonly known as "constructor" or "constructor". A class can have one or more constructors. Of course, sometimes you don't write a constructor. This does not mean that the class does not have a constructor. It still has a default constructor. If multiple constructors are used, their respective parameter lists must be different.
The following uses YSchool as an example to complete this class.

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

The get/set attributes of id and name have also been modified above to only get. Because these attribute values ​​​​are inherent attributes, it is not logical to assign values ​​after instantiation. That is, these properties are read-only.

The default value is mentioned in the code, let’s briefly talk about it here. When declaring a field, you can use the assignment operator "=" to directly add a value to the field, such as

    string name = string.Empty;

This is not assigning a value to a variable. The default value is just a form. The actual assignment of a variable is still in the constructor. middle. Generally, standardized codes require that variables be assigned initial values ​​when declaring them. If there is no assigned field during life, the compiler will add an assignment code to assign the field to the set default value. In fact, no matter whether we add a default value to the field, the field has a default value, but if we do not add a default value artificially, the default value of the field will be 0 or null.
One more thing to note here is that the system default constructor was mentioned earlier, but when the constructor is defined, the system default constructor does not exist. Therefore, if in some cases, both the default constructor and the constructor with parameters are used, the default constructor must be manually defined. For example,

        public YSchool()
        {

        }

or

        public YSchool()
        {
            this.id = 0;

            this.name = @"尚进";
        }

In summary, the canonical expression for instantiating a class should be: class name instance name = new class name (constructor parameter list);

The above is the compilation of basic knowledge of C#: basic knowledge (3) class structure. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!