Zusammenstellung von C#-Grundkenntnissen: Vererbung von Grundkenntnissen (4).

Wie bereits erwähnt, sind die drei Hauptmerkmale der Objektorientierung: Kapselung, Vererbung und Polymorphismus. Wir haben die Kapselung in der Definition der vorherigen Klasse fast vollständig verstanden. Schauen wir uns nun die Merkmale der Vererbung an.
Vererbung ist eigentlich eine Erweiterung einer Klasse auf eine andere Klasse. Letztere wird als Basisklasse und erstere als Unterklasse bezeichnet. Vererbung bedeutet, dass die Unterklasse über alle Attribute und Methoden der Basisklasse verfügt und die Unterklasse auch Attribute und Methoden hinzufügen kann. Unterklassen können jedoch die Attribute und Methoden der übergeordneten Klasse nicht entfernen.
Natürlich sollte hier auch das Problem der Modifikatoren erwähnt werden. Die Unterklasse verfügt über alle Attribute und Methoden der Basisklasse. Dies bedeutet nicht, dass die Unterklasse nach Belieben auf diese geerbten Attribute und Methoden zugreifen kann. Unterklassen können nur auf öffentliche und geschützte Eigenschaften und Methoden zugreifen, auf den Rest kann nicht direkt zugegriffen werden. Eine andere Sache ist, dass statische Eigenschaften und Methoden nicht vererbt werden können, da der statische Typ mit der Klasse zusammenhängt und nichts mit dem Objekt zu tun hat.
Sehen Sie sich den Code an:

using System;

namespace YYS.CSharpStudy.MainConsole
{
    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>
       /// 构造器
       /// </summary>
        public YSchool()
        {
            this.id = 0;

            this.name = @"清华大学附中";
        }
        /// <summary>
        /// 构造器
        /// </summary>
        public  YSchool(int id, string name)
        {
            this.id = id;

            this.name = name;
        }
        /// <summary>
        /// 构造器
        /// </summary>
        public  YSchool(int id)
        {
            this.id = id;

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

    public class YTeacher
    {
        private int id = 0;

        private string name = string.Empty;

        private YSchool school = null;

        private string introDuction = string.Empty;

        private string imagePath = string.Empty;

        /// <summary>
        /// 使用只读属性，因为是固有属性。
        /// </summary>
        public int ID
        {
            get
            {
                return id;
            }
        }

        public string Name
        {
            get
            {
                return name;
            }
        }

        /// <summary>
        /// 这几个使用get/set属性，因为这几个属性不是固有的，可以随着某些条件改变的。
        /// </summary>
        public YSchool School
        {
            get
            {
                if (school == null)
                {
                    school = new YSchool();
                }
                return school;
            }

            set
            {
                school = value;
            }
        }

        public string IntroDuction
        {
            get
            {
                return introDuction;
            }

            set
            {
                introDuction = value;
            }
        }

        public string ImagePath
        {
            get
            {
                return imagePath;
            }

            set
            {
                imagePath = value;
            }
        }

        public YTeacher(int id, string name)
        {
            this.id = id;

            this.name = name;
        }

        /// <summary>
        /// 给学生讲课的方法
        /// </summary>
        public void ToTeachStudents()
        {
            Console.WriteLine(string.Format(@"{0} 老师教育同学们： Good Good Study,Day Day Up!", this.name));
        }
        /// <summary>
        /// 惩罚犯错误学生的方法
        /// </summary>
        /// <param name="punishmentContent"></param>
        public void PunishmentStudents(string punishmentContent)
        {
            Console.WriteLine(string.Format(@"{0} 的{1} 老师让犯错误的学生 {2}。", this.School.Name, this.name, punishmentContent));
        }
    }
    /// <summary>
    /// 男性老师，继承自YTeacher
    /// </summary>
    public class MrTeacher : YTeacher
    {
        /// <summary>
        /// 构造器，这里要注意，YTeacher是没有提供默认构造器的，
        /// 所以子类必须要有构造器，并且和基类参数列表一致。
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        public MrTeacher(int id, string name)

            : base(id, name)
        {

        }
        /// <summary>
        /// 扩展的方法，刮胡子方法。
        /// </summary>
        public void Shave()
        {
            Console.WriteLine(string.Format(@"{0} 老师用飞科剃须刀刮胡子。",this.Name));
        }
    }
    /// <summary>
    /// 女性老师，继承自YTeacher
    /// </summary>
    public class MisTeacher : YTeacher
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        public MisTeacher(int id, string name)

            : base(id, name)
        {

        }
        /// <summary>
        /// 扩展方法，护肤的方法
        /// </summary>
        public void SkinCare()
        {
            Console.WriteLine(string.Format(@"{0} 老师用香奈儿护肤霜护肤。",this.Name));
        }
    }
}

using System;

namespace YYS.CSharpStudy.MainConsole
{
    
    class Program
    {
        static void Main(string[] args)
        {
            MrTeacher mrTeacher = new MrTeacher(1, @"牛轰轰");

            mrTeacher.ToTeachStudents();

            mrTeacher.PunishmentStudents(@"背唐诗");

            mrTeacher.Shave();

            MisTeacher misTeacher = new MisTeacher(2, @"郝漂靓");

            misTeacher.ToTeachStudents();

            misTeacher.PunishmentStudents(@"默写红楼梦");

            misTeacher.SkinCare();

            Console.ReadKey();
        }
    }

Ergebnis:

Vererbung ist eine objektorientierte Funktion und ihre Vorteile sind:
Erstens ermöglicht uns die Vererbung, beim Entwerfen von Klassen für ein Projekt viel Code wegzulassen. Zweitens entspricht sie der Organisationsform von Klassen in objektorientierten Sprachen wie C# und Java Es gibt eine Objektklasse, bei der es sich um die Vorfahrenklasse aller Klassen handelt, von der andere Klassen abgeleitet sind.

Eine Sache, auf die Sie beim Erben achten müssen, ist der Konstruktor von Unterklassen. Während des Programmlaufs ruft die Unterklasse zunächst den Konstruktor der übergeordneten Klasse auf. Wenn die Unterklasse keinen Konstruktor schreibt, wird der Standardkonstruktor der übergeordneten Klasse aufgerufen. Wenn die übergeordnete Klasse keinen Standardkonstruktor hat, das heißt, die übergeordnete Klasse schreibt einen Konstruktor mit Parametern, dann ruft die Unterklasse den Konstruktor mit Parametern auf, Sie müssen jedoch angeben, welcher Konstruktor mit Parametern aufgerufen wird (siehe Basiscode). ).
Das Obige ist die Zusammenfassung der C#-Grundkenntnisse: Grundkenntnisse (4) Vererbung Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!