C# 抽象类总结

C#中的抽象类：

1、声明一个抽象方法使用abstract关键字。

2、一个类中可以包含一个或多个抽象方法。

3、抽象类中可以存在非抽象的方法。

4、抽象方法不能被直接实例化。

5、实现抽象类用“：”（冒号），实现抽象方法用override关键字。

6、抽象类可以被抽象类所继承，结果仍是抽象类。

7、抽象方法被实现后，不能修改修饰符。

public abstract class Person
    {
        public abstract void SayHello();
        public void about()
        {
            Console.WriteLine("Abstract Demo");
        }
    } 

    public class Student : Person
    {
        public override void SayHello()
        {
            Console.WriteLine("SayHello");
        }
    }

    class MainClass
    {
        public static void Main()
        {
            new Student().SayHello();
        }
    }

8、不能被初始化，只提供了部分实现，但另一个类可以继承它并且能创建它们的实例。

9、一个抽象类可以包含抽象和非抽象的方法，当一个类继承于抽象类，那么这个派生类必须实现所有的基类抽象方法。

10、一个抽象方法是没有方法体的方法。

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();
        }
    }

11、通过声明派生类也为抽象类，可以避免所有或特定的虚方法的实现，这即为抽象类的部分实现。

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();
        }
    }

12、一个抽象类能够继承另一个非抽象类，另外，继承了基类的方法，可以添加新的抽象和非抽象方法。

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();
        }
    }

13、一个抽象类也可以从一个接口来实现，这种情况我们必须为所有的方法提供方法体，这些方法来自接口。

 

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();
        }
    }

14、不能把关键字abstract和sealed一起使用，因为一个密封类不能被抽象。

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();
        }
    }