abstract 抽象类 用法

abstract表明一个类是不完整的，只能作为其他类的一个基类。
抽象类与非抽象类的不同之处有：
1.抽象类无法直接用例子说明，且在抽象类中不能使用操作符new。
2.抽象类允许(但不需要)含有抽象成员。

3.抽象类不能被密封(密封类不能被继承)

EXAMPLE：抽象方法没有实现，所以方法定义后面是分好，而不是方法块。
public abstract class A
{
public abstract void AA(int num);
}

EXAMPLE：抽象类的派生类必须实现所有抽象方法。当抽象类从基类继承虚方法时，抽象类可以使用抽象方法重写该虚方法。
public class D
{
public virtual void DoWork(int i){}
}
public abstract class E:D
{
public abstract override void DoWork(int i);
}
public class F:E
{
public override void DoWork(int i)
{
    //new implementation
}
}
如果将virtual方法声明为abstract，则该方法对于从抽象类继承的所有类而言仍然是虚方法。
抽象继承方法的类无法访问该方法的原始实现。在此情况下，抽象类可以强制派生类为虚方法提供新的方法实现。

EXAMPLE：一个抽象类可以包含抽象方法和非抽象方法，当一个类继承于抽象类，那么这个派生类必须实现基类中所有的抽象方法。
public abstract class A
{
    public abstract void FunctionA();
    public void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class B : A
{
    public override void FunctionA()
    {
        Console.WriteLine("override FunctionA");
    }   
}
public class C
{
    static void Main(string[] args)
    {
        B b1 = new B();
        b1.FunctionA();
        b1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

EXAMPLE：通过声明派生类也为抽象类，可以避免所有或特定的虚拟方法的实现。这就是抽象类的部分实现。
public abstract class A
{
    public abstract void FunctionA();
    public abstract void FunctionB();
}
public abstract class B : A
{
    public override void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public class C : B
{
    public override void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class D
{
    static void Main(string[] args)
    {
        C c1 = new C();
        c1.FunctionA();
        c1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

EXAMPLE：一个抽象类可以继承非抽象类。并且，继承了基类的方法，添加新的抽象和非抽象方法是可行的。
public class A
{
    public void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public abstract class B : A
{
    public abstract void FunctionB();
}
public class C : B
{
    public override void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class D
{
    static void Main(string[] args)
    {
        C c1 = new C();
        c1.FunctionA();
        c1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

EXAMPLE：一个抽象类也能从一个接口来实现，这种情况，必须为所有的方法提供方法体，这些方法是来自接口。
public interface I1
{
    void FunctionA();
}
public abstract class A : I1
{
    public void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public class B : A
{
    public void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class C : B
{
    static void Main(string[] args)
    {
        B b1 = new B();
        b1.FunctionA();
        b1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}