Wie in Vererbung und abstrakten Klassen erwähnt, gibt es diese Beziehungen zwischen den Methoden von Unterklassen und übergeordneten Klassen:
Unterklassen verwenden direkt übergeordnete Klassenmethoden (die übergeordneten Klassenmethoden müssen jedoch öffentliche oder geschützte Typen sein);
Die Methode der Unterklasse überschreibt die Methode der übergeordneten Klasse (Override);
Die Methode der Unterklasse überschreibt die Methode der übergeordneten Klasse (Overload);
Sehen Sie sich die folgende Situation an:
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();
}
}
}Ergebnis:
Der Vorgang, bei dem mit new eine neue Methode mit demselben Namen wie die Methode der übergeordneten Klasse und derselben Parameterliste geändert wird, wird als Ausblenden bezeichnet . Das heißt, die Unterklasse verbirgt diese Methode der übergeordneten Klasse. Das Ausblenden unterscheidet sich jedoch vom Überschreiben. Auf eine ausgeblendete Methode kann nur über die Klasse zugegriffen werden, in der sich die Methode befindet. Wenn Sie Variablen der übergeordneten Klasse verwenden, greifen Sie weiterhin auf die ausgeblendete Methode zu.
Aus dem obigen Code können Sie den Unterschied zwischen Verdecken und Verstecken erkennen. Nachdem die Variable der übergeordneten Klasse auf die Instanz der Unterklasse verweist, kann nur auf die verborgene Methode zugegriffen werden, auf die verborgene Methode jedoch nicht. Auf die überschriebenen Methoden kann jedoch zugegriffen werden.
Ein weiterer Punkt ist, dass die übergeordnete Klasse der Methode „virtual“ hinzufügen muss, wenn diese Methode von der Unterklasse überschrieben werden soll. Sie müssen das Schlüsselwort new nicht hinzufügen, um die Methode der übergeordneten Klasse auszublenden. Ausblenden wird im Allgemeinen seltener verwendet und löst in einigen besonderen Situationen einige Probleme.
Das Obige ist die Zusammenstellung des C#-Grundwissens: Der verborgene Inhalt der Methode des Grundwissens (7) Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!
