Compilation des connaissances de base en C# : héritage des connaissances de base (4)

Comme mentionné précédemment, les trois caractéristiques majeures de l'orientation objet : l'encapsulation, l'héritage et le polymorphisme. Nous avons presque entièrement compris l'encapsulation dans la définition de la classe précédente. Examinons maintenant les caractéristiques de l'héritage.
L'héritage est en fait une extension d'une classe à une autre classe. Cette dernière est appelée classe de base et la première est appelée sous-classe. L'héritage signifie que la sous-classe possède tous les attributs et méthodes de la classe de base, et que la sous-classe peut également ajouter des attributs et des méthodes. Cependant, les sous-classes ne peuvent pas supprimer les attributs et méthodes de la classe parent.
Bien entendu, la question des modificateurs doit également être mentionnée ici. La sous-classe possède tous les attributs et méthodes de la classe de base. Cela ne signifie pas que la sous-classe peut accéder à volonté à ces attributs et méthodes hérités. Les sous-classes ne peuvent accéder qu'aux propriétés et méthodes publiques et protégées, et le reste n'est pas accessible directement. Une autre chose est que les propriétés et méthodes statiques ne peuvent pas être héritées, car le type statique est lié à la classe et n'a rien à voir avec l'objet.
Regardez le code :

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

Résultat :

L'héritage est une fonctionnalité orientée objet, et ses avantages sont :
Premièrement, lors de la conception de classes pour un projet, l'héritage nous permet d'omettre beaucoup de code ;
Deuxièmement, il est conforme à la forme organisationnelle des classes orientées objet dans les langages orientés objet avancés tels que C# et Java. , il existe une classe d'objets, qui est toutes les classes de la classe Ancêtre, d'autres classes en dérivent.
Une chose à laquelle vous devez faire attention lors de l'héritage est le constructeur des sous-classes. Pendant le processus d'exécution du programme, la sous-classe appelle d'abord le constructeur de la classe parent. Si la sous-classe n'écrit pas de constructeur, le constructeur par défaut de la classe parent sera appelé. Si la classe parent n'a pas de constructeur par défaut, c'est-à-dire que la classe parent écrit un constructeur avec des paramètres, alors la sous-classe appellera le constructeur avec des paramètres, mais vous devez spécifier quel constructeur avec des paramètres est appelé (voir le code de base) ).
Ce qui précède est le résumé des connaissances de base en C# : héritage des connaissances de base (4) Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !