C#抽象类

1.抽象成员必须标记为abstract,并且不能有任何实现。
2.抽象成员必须在抽象类中。
3.抽象类不能被实例化

4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。

（除非子类也是一个抽象类，则可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员。
并且抽象类的实例成员可以不被子类实现

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

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

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

 class Class1
    {
        static void Main(string[] args)
        {
            //抽象类和接口不允许实例化，但允许装入子类  
            //父类里装的是子类，但是表现出来的是父类，调用的还是父类成员，
            //但父类是抽像类，方法被子类成员重写，所以调用出来的是子类方法
            Animal an = new MaoMi();
            an.Jiao();
            Animal xg = new XiaoGou();
            xg.Jiao();
            xg.jj();
            Console.ReadKey();
        }

    }

    //使用 abstract 声明一个抽象类 ，类似于接口，抽象类多定义于使用规范，在多人协同编写中代码调用类方法一式
    public abstract class Animal
    {
        //抽像方法
        public abstract void Jiao();
      
        private   string _name;


        //抽像属性
        public abstract string Name
        {
            get;
            set;
        }

        public Animal(int age)
        {
            this.Name = _name;
        }
        public Animal()
        { }
        public void jj()
        {
            Console.Write("这里是实例化子类后，可以调用的");
        }
    }

    //声明一个子类
    public class MaoMi:Animal
    {
        public override void Jiao()
        {
            Console.WriteLine("小猫喵喵叫");
        }

        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }

    //声明一个子类
    public class XiaoGou : Animal
    {
        public override void Jiao()
        {
            Console.WriteLine("小狗汪汪叫");
        }



        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }

======
如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。

如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。