[转]C#中的abstract 类和方法

转：https://www.cnblogs.com/zzy2740/archive/2005/09/20/240808.html

C#中的abstract类不能被实例化，他只提供其他类的继承的接口

using System;
abstract class MyAbs
{
    public void NonAbMethod()
    {
        Console.WriteLine("Non-Abstract Method");
    }
}

class MyClass : MyAbs
{
}

class MyClient
{
    public static void Main()
    {
       //MyAbs mb = new MyAbs();//不能实例化
        MyClass mc = new MyClass();
        mc.NonAbMethod();
    }
}

一个抽象类可以包含abstract方法，也可包含实例化方法，但继承类（非抽象）必须实现abstract方法

    abstract class MyAbs
    {
        public void NonAbMethod()
        {
            Console.WriteLine("Non-Abstract Method");
        }
        public abstract void AbMethod(); // 抽象方法，只有声明，没有实现
    }

    class MyClass : MyAbs//必须实现抽象方法
    {
        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();
    }
    //抽象继承类不必全部实现抽象方法，部分实现便可
    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
    {
        public void Method1()
        {
            Console.WriteLine("Method of a non-abstract class");
        }
    }
    abstract class MyAbs : MyClass1
    {
        public abstract void AbMethod1();
    }
    class MyClass : MyAbs//实例类必须实现抽象方法
    {
        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
    {

    }
    class MyClient
    {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.Method1();
        }
    }

最后需要注意的是抽象类不能声明为sealed,这两个语义是冲突的。抽象方法不必（也不能）声明为virtual，因为它缺省隐含就为virtual!

原文地址：https://www.cnblogs.com/sggggr/p/11847293.html