C#中的多态

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _14用虚方法实现多态
{
    public class Person
    {
        public Person(string name)
        {
            this.Name = name;
        }
        public string Name
        {
            get;
            set;
        }

        //1.第一，将父类中的Show方法标记为“虚方法”,virtual
        //2.当一个方法是虚方法的时候，那么这个方法在子类中就可以被重写了.
        //子类继承父类以后，可以直接使用该方法，也可以将该方法重写。
        public virtual void Show()
        {
            Console.WriteLine("父类中的Show方法。");
        }
    }

    /// <summary>
    /// 中国人类
    /// </summary>
    public class Chinese : Person
    {
        public Chinese(string name)
            : base(name)
        {

        }

        //2.子类如果要重写父类中的方法，则需要在子类的Show方法前，加一个override关键字
        //子类重写父类的方法必须并且只能用override关键。
        public override void Show()
        {
            Console.WriteLine("我叫：{0},我是中国人！", Name);
        }
    }

    /// <summary>
    /// 日本人类
    /// </summary>
    public class Japanese : Person
    {
        public Japanese(string name)
            : base(name)
        {

        }
        public override void Show()
        {
            Console.WriteLine("我叫：{0},我是日本人！", Name);
        }
    }

    public class American : Person
    {
        public American(string name)
            : base(name)
        {

        }
        public override void Show()
        {
            Console.WriteLine("我叫：{0},我是美国人。", Name);
        }
    }

    /// <summary>
    /// 英国人类。
    /// </summary>
    public class English : Person
    {
        public English(string name)
            : base(name)
        {

        }

        public override void Show()
        {
            Console.WriteLine("我叫：{0},我是英国人。", Name);
        }
    }


}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _15通过虚方法实现方法重写的练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //Manager man = new Manager();
            //man.DaKa();
            //Console.ReadKey();

            //Employee emp = new ShaoGuoluDe();//new Manager();
            //emp.DaKa();
            //Console.ReadKey();

            Person p = new Driver();
            p.SayHello();
            Console.ReadKey();
        }
    }

    class Employee
    {
        public virtual void DaKa()
        {
            Console.WriteLine("员工早上8:00打卡。");
        }
    }

    class Manager : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("经理早上7:30打卡。");
        }
    }

    class ShaoGuoluDe : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("晚上12:00打卡。");
        }
    }


}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _19sealed关键字_1密封类
{
    class Program
    {
        static void Main(string[] args)
        {
            //Chinese c = new Chinese();

            //Console.WriteLine("ok");
            //Console.ReadKey();
            //string s = "aa";

            Person p = new BeiJingren();
            p.SayHi();
            Console.ReadKey();

        }
    }

    public class Person
    {
        public string Name
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string Email
        {
            get;
            set;
        }

        public virtual void SayHi()
        {
            Console.WriteLine("hi in Person.");
        }
    }

    class Chinese : Person
    {
        //禁止子类重写该方法。
        public sealed override void SayHi()
        {
            Console.WriteLine("hi in Chinese");
        }
    }

    class BeiJingren : Chinese
    {
        //public override void SayHi()
        //{
        //    Console.WriteLine("hi in BeiJingren");
        //}
    }


    //public sealed class Person
    //{
    //    public string Name
    //    {
    //        get;
    //        set;
    //    }
    //    public int Age
    //    {
    //        get;
    //        set;
    //    }
    //    public string Email
    //    {
    //        get;
    //        set;
    //    }
    //}

    //class Chinese : Person
    //{

    //}
    //class MyString:String
    //{

    //}
}

当对一个类应用 sealed 修饰符时，此修饰符会阻止其他类从该类继承

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _02通过抽象方法实现多态
{
    class Program
    {
        static void Main(string[] args)
        {

            Chinese cn = new Chinese();

            //抽象类是不能被实例化的。（抽象类的作用就是为了让继承。）
           // Person p = new Person();


        }
    }

    //这个类也必须标记为abstract(抽象)的。
    //抽象成员必须写在抽象类中。不能写在一个实例中。
    public abstract class Person
    {

        public string Name
        {
            get;
            set;
        }
        //可以包含抽象方法、属性、索引器、事件。【其实这几个最后都是方法。】
        //抽象属性，没有任何实现（不要与自动属性误解）
        public abstract int Age
        {
            get;
            set;
        }

        public void SayHi()
        {
            Console.WriteLine("Hi~~,我不抽象。");
        }

        //1.抽象方法不能有任何方法体。(不能有任何实现)
        //抽象成员不能是private
        public abstract void Show();
    }

    public class Chinese : Person
    {

        /// <summary>
        /// 3.父类中的抽象成员，子类继承以后必须重写（例外：除非子类也是一个抽象类。）
        /// </summary>
        public override void Show()
        {
            Console.WriteLine("我是中国人！");
        }

        public override int Age
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }

    //抽象类中
    public abstract class Japanese : Person
    {

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _09new关键字用来隐藏父类方法
{
    class Program
    {
        static void Main(string[] args)
        {
            ////Person p = new Chinese();
            ////p.SayHi();
            ////Console.ReadKey();

            //Chinese cn = new Chinese();
            //cn.SayHi();
            //Console.ReadKey();

            B b = new B();
            b.SayHello();
            Console.ReadKey();
        }
    }
    class Person
    {
        public virtual void SayHi()
        {
            Console.WriteLine("父类中的SayHI方法！");
        }
    }

    class Chinese : Person
    {
        ////方法重写
        //public override void SayHi()
        //{
        //    Console.WriteLine("子类中的SayHi");
        //}

        //在子类中写了一个全新的方法SayHi,同时隐藏了从父类继承下来的SayHi方法。
        public new void SayHi()
        {
            Console.WriteLine("子类中的SayHi");
        }
    }
}

总结 ： 实现多态的方式有三种方法，标记类的方法为virtual虚方法，override重载的方法，abstract抽象类下的抽象方法、new（）重写虚方法等及属性。想让重载的方法无法被继承就使用sealed关键字