C# 虚方法多态、抽象类多态、接口

C# 虚方法多态、抽象类多态
虚方法：希望重新父类中的某个方法时，使用虚方法
抽象类：有多个规定的处理方式，但实际实现的方式不同，使用抽象类

抽象类就是为了设立规范，为了互相统一和方便。

在一个类型下，某种方法，有无数种变化。
例如：不同种类的鸭子（class）有不同的叫法（方法），使用父类设计一个鸭子类，在子类中重写它的叫法。

在无数种类型下，固定几种方式，方式实现的具体都不一样。
例如：出现多种形状的物体，求矩形和面积，使用一个抽象类，固定矩形和面积两种方式，让其他类去具体写这两种方式。

虚方法多态

using System.ComponentModel;
using System.Xml.Linq;

namespace ConsoleApp1
{


    internal class Class1
    {
        static void Main(string[] args)
        {
            // 鸭子叫：真的 嘎嘎、木头 吱吱、 橡皮 叽叽、
            // 使用多态的虚方法，实现多种变化 
            // 父类关键字：virtual、子类关键字：override、
            ReaIDuck rd = new ReaIDuck();
            MuDuck md = new MuDuck();
            XPDuck xd = new XPDuck();

            ReaIDuck[] ducks = {rd, md, xd};

            for (int i = 0; i < ducks.Length; i++)
            {
                ducks[i].Bark();
            }

        }

    }
    // 父类 
    public class ReaIDuck
    {
        public virtual void Bark()
        {
            Console.WriteLine("真的鸭子 嘎嘎叫");
        }
    }
    // 子类
    public class MuDuck: ReaIDuck
    {
        public override void Bark()
        {
            Console.WriteLine("木头鸭子 吱吱叫");
        }
    }
    // 子类
    public class XPDuck: ReaIDuck
    {
        public override void Bark()
        {
            Console.WriteLine("橡皮鸭子 叽叽叫");
        }
    }
}

抽象类多态

using System.ComponentModel;
using System.Xml.Linq;

namespace ConsoleApp1
{


    internal class Class1
    {
        static void Main(string[] args)
        {
            // 使用多态：求矩形的面积与周长、求圆的面积和周长、
            // 此时，应该使用抽象类方法，将面积与周长的方法做一个抽象，因为具体的实现方法不一样。

            // 实例化
            // 圆的面积与周长
            Shape shape = new Circle(5);

            double area = shape.GetArea();
            double perimeter = shape.GetPerimeter();
            Console.WriteLine("圆 面积：{0:0.00}，周长：{1:0.00}", area, perimeter);

            // 矩形的面积与周长
            Shape shape1 = new Square(6, 7);
            double area1 = shape.GetArea();
            double perimeter1 = shape.GetPerimeter();
            Console.WriteLine("矩形 面积：{0:0.00}，周长：{1:0.00}", area1, perimeter1);

        }
    }
    // 抽象类 关键字：abstract
    public abstract class Shape
    {
        // 求面积
        public abstract double GetArea();
        // 求周长
        public abstract double GetPerimeter();
    }

    // Ait + Shift + F10 快捷键
    // 圆形类
    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 * 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)
        {
            Height = height;
            Width = width;
        }
        // 矩形 面积
        public override double GetArea()
        {
            return this.Height * this.Width;
        }
        // 矩形周长
        public override double GetPerimeter()
        {
            return (this.Height + this.Width) * 2;
        }

    }
}

接口

namespace ConsoleApp1
{
    internal class Class1
    {
        static void Main(string[] args)
        {
            // 接口可以多继承
            // 接口可以继承接口，不可继承类
            // 类可以继承1个类，多个接口

            // 我是动物运动会主办方，不知道有多少种动物，不知道他们都会什么
            // 在设计时，只能设计比赛项目，例如游泳比赛的各种行为细节，以及评价标准等。

            // 假设 有一类动物，他许多比赛都可以参加，此时可以用多继承来增加它的比赛项目

            // 真的鸭子会游泳、木头鸭子不会游泳、橡皮鸭子会游泳、

            ISwimming swim = new ReaIDuck();
            swim.Swim();

            ISwimming swim1 = new XPDuck();
            swim1.Swim();

            Console.WriteLine("");

        }
    }

    public class ReaIDuck:ISwimming
    {
        public void Swim()
        {
            Console.WriteLine("真的鸭子会直接游泳");
        }

    }
    public class MuDuck
    {
        // 木头鸭子不会游泳
        
        
    }


    public class XPDuck: ISwimming
    {
        public void Swim()
        {
            Console.WriteLine("橡皮鸭子靠橡皮游泳");
        }
    }

    // 接口关键字：interface
    // 命名规范：I开头 
    public interface ISwimming
    {
        // 接口内部 不允许写：字段、具有方法体的函数、
        void Swim();
    }
}