C#基础继承和多态详解

继承

　　在现有类（称为基类、父类）上建立新类（称为派生类、子类）的处理过程为继承。派生类能自动获取基类（除了构造函数和析构函数外的所有成员），可以在派生类中添加新的属性和方法扩展其功能。

using system;
using system.collections.generic;
using system.linq;
using system.web;

public class person
{

    private string _id;
    public string id
    {
        get { return _id; }
        set { _id = value; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="id"></param>
    public person(string id)
    {
        _id = id;
    }

    /// <summary>
    /// 无参构造函数
    /// </summary>
    /// <param name="id"></param>
    /// <param name="class"></param>
    public person()
    {
    }

    public string getid()
    {
        return id;
    }

}

//<访问修饰符>class 派生类名：基类名
public class student : person
{
    private string _class;

    public string class
    {
        get { return _class; }
        set { _class = value; }
    }

    /// <summary>
    /// 无参构造函数
    /// </summary>
    /// <param name="id"></param>
    /// <param name="class"></param>
    public student()
    {

    }

    public string getclass()
    {
        return class;
    }
}

public class newstudent:student
{
    /// <summary>
    /// 无参构造函数
    /// </summary>
    /// <param name="id"></param>
    /// <param name="class"></param>
    public newstudent()
    {
    }

    private string _nid;
    public string nid;

    public string getnid()
    {
        return nid;
    }
}

    protected void page_load(object sender, eventargs e)
    {
        person p = new person("id1111111");
        student s = new student();
        newstudent n = new newstudent();

        s.id = "id2222222";
        s.class = "12班";

        n.nid = "nid3333333";
        n.id = "id3333333";
        n.class = "13班";
        label1.text = p.getid();
        label2.text = s.getid()+s.getclass();
        label3.text = n.getid() + s.getclass() + n.getnid();

        //输出结果 id1111111111 id222222212班 id333333312班nid3333333
    }

　　从上面的例子可以看出，继承的可传递性，如果c从b中派生，b又从a派生。那么c不仅继承了b中的成员，同样也继承了a中的成员。继承的单一性指派生类只能从一个基类中继承，不能同时继承多个基类。派生类只能访问基类中public,protected,internal修饰的成员　

　　base关键字用于在派生类调用基类的构造函数、属性和方法。

    public student(string id):base(id) //调用基类的构造函数
    {

    }

　多态的实现（virtual override abstract的使用）

　　在c#的学习中，容易混淆virtual方法和abstract方法的使用，现在来讨论一下二者的区别。二者都牵涉到在派生类中与override的配合使用。
1、virtual方法（虚方法）

     virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况：

     情况1：在基类中定义了virtual方法，但在派生类中没有重写该虚方法。那么在对派生类实例的调用中，该虚方法使用的是基类定义的方法。

     情况2：在基类中定义了virtual方法，然后在派生类中使用override重写该方法。那么在对派生类实例的调用中，该虚方法使用的是派生重写的方法。

2、abstract方法（抽象方法）

     abstract关键字只能用在抽象类中修饰方法，并且没有具体的实现。抽象方法的实现必须在派生类中使用override关键字来实现。

public abstract class person
{

    private string _id;
    public string id
    {
        get { return _id; }
        set { _id = value; }
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="id"></param>
    public person(string id)
    {
        _id = id;
    }

    /// <summary>
    /// 无参构造函数
    /// </summary>
    /// <param name="id"></param>
    /// <param name="class"></param>
    public person()
    {
    }

    public virtual string getid()
    {
        return "虚方法可覆盖";
    }

    public virtual string getid1()
    {
        return "虚方法可覆盖";
    }

    public string getid2()
    {
        return "一般的方法，在派生类重写，需要用new";
    }

    public abstract string getid3(); //抽象方法，不含主体 派生类必须继承此方法
}

//<访问修饰符>class 派生类名：基类名
public class student : person
{
    private string _class;

    public string class
    {
        get { return _class; }
        set { _class = value; }
    }

    public student()
    {
    }

    public student(string id):base(id) //调用基类的构造函数
    {

    }

    public override string getid()
    {
        return "虚方法可覆盖-用override";
    }

    public new string getid2()
    {
        return "普通方法可覆盖-用new";
    }
    public override string getid3()
    {
        return "抽象方法必须实现-用override";
    }

}

    protected void page_load(object sender, eventargs e)
    {
        var a = new student();
        label1.text = a.getid() ;
        label2.text = a.getid1();
        label3.text = a.getid2();
        label4.text = a.getid3();
        //运行结果
        //虚方法可覆盖-用override 虚方法可覆盖 普通方法可覆盖-用new 抽象方法必须实现-用override

    }