c#基础多态的三种手段

//1.虚方法

//1)、虚方法
//步骤：
//1、将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一个遍。

 public class Employee
    {
        public virtual void DaKa()
        {
            Console.WriteLine("九点打卡");
        }
    }

 public class Manager : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("经理11点打卡");
        }
    }
 public class Programmer : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("程序猿不打卡");
        }
    }

//抽象类1

//2)、抽象类
//当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。

 public abstract class Animal//抽象类
    {

        public virtual void T()
        {
            Console.WriteLine("我是虚方法");
            //如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。

           // 如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。
        }
        //6.在抽象类中可以包含实例成员。
      //  并且抽象类的实例成员可以不被子类实现
        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public Animal(int age)
        {
            this.Age = age;
        }
        public abstract void Bark();//抽象方法 1.抽象成员必须标记为abstract,并且不能有任何实现。
        public abstract string Name//抽象属性
        {
            get;
            set;//
                //4. 抽象属性 子类继承抽象类后，必须把父类中的所有抽象成员都重写。
        }

     //   public abstract string TestString(string name);

//2.抽象成员必须在抽象类中。
//3.抽象类不能被实例化
        public Animal()
        { 
            
        }
        //public void Test()
        //{ 
        //    //空实现
        //}
    }

  public abstract class Test : Animal
    {
        //（除非子类也是一个抽象类，则可以不重写） 
    }

public class Dog : Animal//alt +shirt+F10
    {
       // public abstract void Test();


        public override void Bark()
        {
            Console.WriteLine("狗狗旺旺的叫");
        }

        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
                         //string
        //public override string TestString(string name)
        //{
        //    //throw new NotImplementedException();
        //}
        //如果父类的抽象方法中有参数，那么。继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

        //如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候 也必须要传入返回值。
    }

//抽象类2
 public abstract class Shape
    {
        public abstract double GetArea();
        public abstract double GetPerimeter();
    }

 public abstract class Shape
    {
        public abstract double GetArea();
        public abstract double GetPerimeter();
    }

 public class Circle : Shape
    {

        private double _r;
        public double R
        {
            get { return _r; }
            set { _r = value; }
        }

        public Circle(double r)
        {
            this.R = r;
        }
        public override double GetArea()
        {
            return Math.PI * this.R * this.R;
        }

        public override double GetPerimeter()
        {
            return 2 * Math.PI * this.R;
        }
    }
    public class Square : Shape
    {
        private double _height;

        public double Height
        {
            get { return _height; }
            set { _height = value; }
        }

        private double _width;

        public double Width
        {
            get { return _width; }
            set { _width = value; }
        }

        public Square(double height, double width)
        {
            this.Height = height;
            this.Width = width;
        }

        public override double GetArea()
        {
            return this.Height * this.Width;
        }

        public override double GetPerimeter()
        {
            return (this.Height + this.Width) * 2;
        }
    }

 public interface IFlyable
    {
        //接口中的成员不允许添加访问修饰符 ，默认就是public
        void Fly();
        string Test();
        //不允许写具有方法体的函数

     //   string _name;//不能含字段
         string Name
        {
            get;//自动属性
            set;
        }
    
    }

                             //为了多态。
           // 接口不能被实例化。
          //也就是说，接口不能new(不能创建对象)
            IFlyable fly1 = new Bird();


 //显示实现接口就是为了解决方法的重名问题
            IFlyable fly = new Bird();
            IFlyable FLY1 = new Bird();
            fly.Fly();
            Bird bird = new Bird();
            bird.Fly();



public class Bird : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鸟飞会");
        }
        /// <summary>
        /// 显示实现接口
        /// </summary>
        // void IFlyable.Fly()
        //{
        //    Console.WriteLine("我是接口的飞");
        //}
        void IFlyable.Fly() { Console.Write("我是接口的飞"); }     

    }

  public interface IFlyable
    {
        void Fly();
    }