C#继承多态

       将基类的方法定义为虚拟方法,而在派生类中对虚拟方法进行重载.
  这种方法的优势在于实现运行时多态性,即程序在运行过程中确定调用哪一个成员方法 .
  如果在派生类中使用了override关键字定义了重载方法,那么也允许该类自己的派生类继续重载这个方法,
  因此,重载方法默认也是一种虚拟方法.但不能同时使用virtual和override修饰一个方法.  此外,在基类
  中定义了虚拟方法.实际上暗示了希望在派生类中继承并重载该方法,因此虚拟方法不能是私有的;而且在基类
  和派生类中,对同一个虚拟方法和重载方法的访问限制应该相同.
     抽象类之间也可以继承.抽象类要求所有派生类都继承他的抽象方法.包含抽象方法的类必须是抽象类,
  因此也需要abstact加以修饰

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CsharpCode
{
    
    /// <summary>
    /// 基类:联系人
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public class Contact
    {
        private string m_name;
        private string m_homePhon = "000";
        private string m_busiPhone = "000";
        public string name
        {
            get { return m_name;  }
            set { m_name = value; }
        }
        
        public string this[string type]
        {
            get
            {
                string _gtype = type.ToUpper();
                switch (_gtype)
                {
                    case "住宅电话":
                        return m_homePhon;
                    case "办公电话":
                        return m_busiPhone;
                    default :
                        return null;
                }
            }
            set
            {
                string _stype = type.ToUpper();
                switch (_stype)
                {
                    case "住宅电话":
                        this.m_homePhon = value;
                        break;
                    case "办公电话":
                        this.m_busiPhone = value;
                       break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
          
        }
        public Contact() { }
        public Contact(string name, string homephone, string busiphone)
        {
            this.m_name = name;
            this.m_homePhon = homephone;
            this.m_busiPhone = busiphone;
        }
        public void Output()
        {
            Console.WriteLine("姓名:{0}",m_name);
            Console.WriteLine("住宅电话:{0}", m_homePhon);
            Console.WriteLine("办公电话:{0}", m_busiPhone);
        }

        //采用虚函数定义
        public virtual void Display()
        {
            Console.WriteLine("姓名:{0}", m_name);
            Console.WriteLine("住宅电话:{0}", m_homePhon);
            Console.WriteLine("办公电话:{0}", m_busiPhone);

        }
    }

    public class Bussiness : Contact
    {
        private string _Address = "咸宁";
        public string Address
        {
            get { return _Address; }
            set { _Address = value; }
        }
        public Bussiness() { }
        /// <summary>
        /// 带参数的构造函数用base关键字调用基类的构造函数
        /// </summary>
        /// <param name="name"></param>
        /// <param name="homephone"></param>
        /// <param name="busiphone"></param>
        /// <param name="address"></param>
        public Bussiness(string name, string homephone, string busiphone, string address)
            : base(name, homephone, busiphone)
        {
            this._Address = address;
        }
        public new void Output()//new关键字隐藏基类相同的方法
        {
            base.Output();//通过base关键字调用基类隐藏的Ouoput的方法
            Console.WriteLine("地址:{0}", _Address);
        }
        //重载基类的虚方法
        public override void Display()
        {
            base.Output();//通过base关键字访问当前对象的基类对象的方法
            Console.WriteLine("地址:{0}", _Address);
        }
    }
    public class Classmate : Contact
    {
        private string _num = "000";
        public string num
        {
            get { return _num; }
            set { _num = value; }
        }
        public Classmate() { }
        /// <summary>
        /// 带参数的构造函数用base关键字调用基类的构造函数
        /// </summary>
        /// <param name="name"></param>
        /// <param name="homephone"></param>
        /// <param name="busiphone"></param>
        /// <param name="address"></param>
        public Classmate(string name, string homephone, string busiphone, string num)
            : base(name, homephone, busiphone)
        {
            this._num = num;
        }
       
        //重载基类的虚方法
        public override void Display()
        {
            base.Output();//通过base关键字访问当前对象的基类对象的方法
            Console.WriteLine("学号:{0}", _num);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            Contact c1 = new Contact();
            c1.name = "咸宁";
            c1["住宅电话"] = "123456789";
            c1["办公电话"] = "987654321";
            c1.Output();
            Console.WriteLine("--------------------");
            Bussiness b1 = new Bussiness();
            b1.name = "张三";
            b1["办公电话"] = "222222";
            b1.Address = "咸宁温泉";
            b1.Output();
            Console.WriteLine("--------------------");
            Contact c2 = new Contact("111", "13596357854", "13485697699");
            c2.Output();
            Console.WriteLine("通过构造函数来实现");
            Bussiness b2 = new Bussiness("222", "13688888888", "137899999999","咸安温泉大道");
            b2.Output();
            Console.WriteLine("通过虚函数的方法来实现");
            //将基类的方法定义为虚拟方法,而在派生类中对虚拟方法进行重载.
            //这种方法的优势在于实现运行时多态性,即程序在运行过程中确定调用哪一个成员方法           
            Bussiness b3 = new Bussiness("333","13896326548","13963251478","咸宁市温泉区咸宁大道中心校区");         
            Classmate classmate = new Classmate("444", "13855555558", "13977777777", "010004442");
            Contact c3 = b3;
            //把派生类类对象赋给基类对象,通过基类的对象(实际指向派生类)去调用派生类的方法
            c3.Display();
            c3 = classmate;
            c3.Display();

        }
    }


}