继承

面向对象三要素：继承  封装  多态

一，继承：2019-11-29

基础：所有类都派生于System.Object

           C#支持单重继承和多层继承

           单重继承：一个类仅能继承一个父类

           多层继承：类C继承自B,类B又继承自A

实现继承：创建一个父类和接口

    public class Son : Father,IFather
    {
        //代码
        //如果类和接口都用于派生，则类必须放在接口前面
    }

虚方法：父类可以实现这个方法，子类也可以重写这个方法（不具有强制性）

    public class Father
    {
        public virtual void Draw1()
        {
            Console.WriteLine("父类中第一次实现这个方法");
        }
        public virtual void Draw2() =>Console.WriteLine( "父类中第二次实现这个方法");
    }

    public class Son : Father,IFather
    {
        //代码
        //如果类和接口都用于派生，则类必须放在接口前面
    }

    class Program
    {
        static void Main(string[] args)
        {
            Son son = new Son();
            son.Draw1();
            son.Draw2();
            Console.Read();
        }
    }

 重写父类中的虚方法

    public class Son : Father,IFather
    {
        public override void Draw2()
        {
            base.Draw2();//base.代表父类中的方法
            Console.WriteLine("子类中重写Draw2方法");
        }
    }

 二，继承：2019-11-30

子类继承父类中的构造方法

        父类中的构造方法   
        public Father() { }
        public Father(string name)
        {
            Console.WriteLine($"父类输出构造方法{name}");        
        }

Father

      子类中的构造方法通过base关键字调用父类中构造方法
       public Son(string name)
            :base(name)
        {
            Console.WriteLine($"子类输出构造方法{name}" );
        }

Son

      实例化子类
      static void Main(string[] args)
        {
            Son son = new Son("哈哈");
            Console.Read();
        }

Main

 抽象方法：抽象方法必须放到抽象类中，但是一个抽象方法可以不包括任何抽象类

                   父类提供一个抽象方法，子类必须强制性的重写（除非子类也是抽象类）

                   抽象类不能实例化。

创建抽象类

public abstract class Father

抽象类中创建抽象方法

public abstract void Eat();

子类中重写抽象方法

        public override void Eat()
        {
            Console.WriteLine("抽象方法重写");     
        }

调用抽象方法

        static void Main(string[] args)
        {
            Son son = new Son("哈哈");
            son.Eat();
           
            Console.Read();
        }

多态：根据传递的子类来调用抽象方法

方法一

    /// <summary>
    /// 创建抽象类及抽象方法
    /// </summary>
    public abstract class Father
    {
        public abstract void Eat();
    }

    public class Son : Father,IFather
    {
        public override void Eat()
        {
            //子类中进行重写抽象方法
            Console.WriteLine("抽象方法重写");     
        }
    }

        /// <summary>
        /// 在Program中创建以父类为参数对象的方法
        /// </summary>
        /// <param name="father"></param>
        public static void Execute(Father father)
        {
            father.Eat();
        }

        static void Main(string[] args)
        {
            Execute(new Son());//传递参数
            Console.Read();
        }

方法二

利用返回值，方法与上面相似

        public static Father Execute2()
        {
            return new Son();
        }

        static void Main(string[] args)
        {
           Father father= Execute2();//传递参数
            father.Eat();
            Console.Read();
        }