C#面向对象多态抽象类

抽象类

当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法
1. 抽象类成员必须标记为abstract，并且不能有任何实现。
2.抽象成员必须在抽象类中
3.抽象类不能被实例化

4.子类继承抽象类后，必须把父类中的所有抽象成员都重写（除非子类也是一个抽象类，这样可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员，并且抽象类的实例成员可以不被子类实现

7.抽象类是有构造函数的，虽然不能被实例化。

8.如果父类的抽象方法中有参数，那么，继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数，
如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候 也必须传入返回值。

如果父类中的方法有默认的实现，并且父类需要被实例化，这是可以考虑将父类定义成一个普通类，用虚方法来实现多态
如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。

using System;
using System.Collections;
using System.IO;

namespace 抽象类
{
    class Program
    {
        static void Main(string[] args)
        {
            Shape s = new Circle(5);
            Shape ss = new Square(3, 4);
            double yarea = s.Area();
            double yzc = s.ZhouChang();
            double carea = ss.Area();
            double czc = ss.ZhouChang();
            Console.WriteLine("圆的周长为{0}，面积为{1}",yzc,yarea);
            Console.WriteLine("矩形的周长为{0}，面积为{1}",czc,carea);
        }
    }

    public abstract class Shape
    {
        public abstract double Area();
        public abstract double ZhouChang();
    }

    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 Area()
        {
            return Math.PI * this.R * this.R;
        }

        public override double ZhouChang()
        {
            return 2 * Math.PI *this.R;
        }
    }

    public class Square:Shape
    {
        private double _a;
        private double _b;

        public double A
        {
            get { return _a; }
            set { _a = value; }
        }

        public double B
        {
            get { return _b; }
            set { _b = value; }
        }

        public Square(double a,double b)
        {
            this.A = a;
            this.B = b;
        }

        public override double Area()
        {
            return this.A * this.B;
        }

        public override double ZhouChang()
        {
            return (this.A + this.B) * 2;
        }
    }
}