Compilation des connaissances de base en C# : connaissances de base (7) masquage des méthodes

Comme mentionné dans l'héritage et les classes abstraites, il existe ces relations entre les méthodes des sous-classes et les classes parentes :
Les sous-classes utilisent directement les méthodes de la classe parent (mais les méthodes de la classe parent doivent être de type public ou protégé
) ; La méthode de la sous-classe remplace la méthode de la classe parent (override) ;
La méthode de la sous-classe remplace la méthode de la classe parent (surcharge)
Regardez la situation suivante :

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

        public YSchool()
        {
            this.id = 0;

            this.name = @"清华大学附中";
        }

        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;

        public int ID
        {
            get
            {
                return id;
            }
        }

        public string Name
        {
            get
            {
                return name;
            }
        }

        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;
            }
        }
        /// <summary>
        /// 构造器
        /// </summary>
        public YTeacher(int id, string name)
        {
            this.id = id;

            this.name = name;
        }

        /// <summary>
        /// 构造器
        /// </summary>
        public YTeacher(int id, string name, YSchool school)
        {
            this.id = id;

            this.name = name;

            this.school = school;
        }

        /// <summary>
        /// 给学生讲课的方法
        /// </summary>
        public void ToTeachStudents()
        {
            Console.WriteLine(string.Format(@"{0} 老师教育同学们： Good Good Study,Day Day Up!", this.Name));
        }
        /// <summary>
        /// 惩罚犯错误学生的方法
        /// 加virtual关键字，表示该方法可以被覆盖重写
        /// </summary>
        /// <param name="punishmentContent"></param>
        public virtual void PunishmentStudents(string punishmentContent)
        {
            Console.WriteLine(string.Format(@"{0} 的{1} 老师让犯错误的学生 {2}。", this.School.Name, this.name, punishmentContent));
        }
    }

    public class UniversityTeacher : YTeacher
    {
        public UniversityTeacher(int id, string name,YSchool school)

            : base(id, name, school)
        {

        }

        /// <summary>
        /// 隐藏父类的同名方法，隐藏后该类只能访问隐藏后的方法，不能访问到父类的该方法了。
        /// </summary>
        public new void ToTeachStudents()
        {
            Console.WriteLine(string.Format(@"{0} 老师教育同学们：认真学习.net!", this.Name));
        }
        
        /// <summary>
        /// 覆盖
        /// </summary>
        public override void PunishmentStudents(string punishmentContent)
        {
            base.PunishmentStudents(punishmentContent);//也可以不执行父类方法。

            //自己的代码
        }
    }

using System;

namespace YYS.CSharpStudy.MainConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            UniversityTeacher uTeacher = new UniversityTeacher(3, @"董边成", new YSchool(3, @"清华大学"));

            //访问的是子类方法
            uTeacher.ToTeachStudents();
            //可以访问覆盖后的方法
            uTeacher.PunishmentStudents(@"让你挂科。");

            YTeacher teacher = new UniversityTeacher(3, @"董边成", new YSchool(3, @"清华大学"));
            //访问不到隐藏的那个方法了
            teacher.ToTeachStudents();
            //可以访问覆盖后的方法
            teacher.PunishmentStudents(@"跑10000米。");

            Console.ReadKey();
        }
    }
}

Résultat :

Le processus d'utilisation de new pour modifier une nouvelle méthode avec le même nom que la méthode de la classe parent et la même liste de paramètres est appelé masquage . Autrement dit, la sous-classe masque cette méthode de la classe parent. Cependant, le masquage est différent de l'écrasement. Une méthode cachée n'est accessible que via la classe dans laquelle se trouve la méthode. Si vous utilisez des variables de la classe parent, vous accéderez toujours à la méthode cachée.
À partir du code ci-dessus, vous pouvez voir la différence entre couvrir et cacher. Une fois que la variable de classe parent fait référence à l'instance de sous-classe, seule la méthode cachée est accessible, mais la méthode cachée n'est pas accessible. Cependant, les méthodes remplacées sont accessibles.
Un autre point est que si vous souhaitez que cette méthode soit remplacée par la sous-classe, alors la classe parent doit ajouter virtual à la méthode. Vous n'avez pas besoin d'ajouter le nouveau mot-clé pour masquer la méthode de la classe parent. Hide est généralement moins utilisé et résout certains problèmes dans certaines situations particulières.

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