抽象类和抽象方法。

abstract  class  ShapesClass
        {
                abstract  public  int  Area();
        }
        class  Square  :  ShapesClass
        {
                int  x,  y;
                //  Not  providing  an  Area  method  results
                //  in  a  compile-time  error.
                public  override  int  Area()
                {
                        return  x  *  y;
                }
        }

例如，一个包含非抽象方法的抽象类：

        abstract  class  MyAbs
        {
                public  void  NonAbMethod()
                {
                        Console.WriteLine(“Non-Abstract  Method”);
                }
        }
        class  MyClass  :  MyAbs
        {
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                        //MyAbs  mb  =  new  MyAbs();//not  possible  to  create  an  instance
                        MyClass  mc  =  new  MyClass();
                        mc.NonAbMethod();  //  Displays  ’Non-Abstract  Method’
                }
        }

  abstract  class  MyAbs
        {
                public  void  NonAbMethod()
                {
                        Console.WriteLine(“Non-Abstract  Method”);
                }
                public  abstract  void  AbMethod();  //  An  abstract  method
        }
        class  MyClass  :  MyAbs//must  implement  base  class  abstract  methods
        {
                public  override  void  AbMethod()
                {
                        Console.WriteLine(“Abstarct  method”);
                }
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                        MyClass  mc  =  new  MyClass();
                        mc.NonAbMethod();
                        mc.AbMethod();
                }
        }

abstract  class  MyAbs
        {
                public  abstract  void  AbMethod1();
                public  abstract  void  AbMethod2();
        }
        //not  necessary  to  implement  all  abstract  methods
        //partial  implementation  is  possible
        abstract  class  MyClass1  :  MyAbs
        {
                public  override  void  AbMethod1()
                {
                        Console.WriteLine(“Abstarct  method  #1”);
                }
        }
        class  MyClass  :  MyClass1
        {
                public  override  void  AbMethod2()
                {
                        Console.WriteLine(“Abstarct  method  #2”);
                }
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                        MyClass  mc  =  new  MyClass();
                        mc.AbMethod1();
                        mc.AbMethod2();
                }
        }

  class  MyClass1  //  Non-Abstract  class
        {
                public  void  Method1()
                {
                        Console.WriteLine(“Method  of  a  non-abstract  class”);
                }
        }
        abstract  class  MyAbs  :  MyClass1  //  Inherits  from  an  non-abstract  class
        {
                public  abstract  void  AbMethod1();
        }
        class  MyClass  :  MyAbs//must  implement  base  class  abstract  methods
        {
                public  override  void  AbMethod1()
                {
                        Console.WriteLine(“Abstarct  method  #1  of  MyClass”);
                }
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                        MyClass  mc  =  new  MyClass();
                        mc.Method1();
                        mc.AbMethod1();
                }
        }

        interface  IInterface
        {
                void  Method1();
        }
        abstract  class  MyAbs  :  IInterface
        {
                public  void  Method1()
                {
                        Console.WriteLine(“Method  implemented  from  the  IInterface”);
                }
        }
        class  MyClass  :  MyAbs//must  implement  base  class  abstract  method
        {
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                MyClass  mc  =  new  MyClass();
                mc.Method1();
                }
        }  
  。   abstract  class  MyAbs
        {
                public  abstract  void  AbMethod1();
                public  abstract  void  AbMethod2();
        }
        class  MyClass1  :  MyAbs
        {
                public  override  void  AbMethod1()
                {
                        Console.WriteLine(“Abstarct  method  #1  of  MyClass1”);
                }
                public  override  void  AbMethod2()
                {
                        Console.WriteLine(“Abstarct  method  #2  of  MyClass1”);
                }
        }
        class  MyClient
        {
                public  static  void  Main()
                {
                        MyAbs  ma1  =  new  MyClass1();//  Polymorphism
                        ma1.AbMethod1();
                        ma1.AbMethod2();
                }
        }

interface  I  
{
        void  M();
}
abstract  class  C:  I  
{
        public  abstract  void  M();
}

抽象类具有以下特征：

5.在方法和属性中使用abstract 关键字意味着包含它们的实现。