C# 关于接口与基类的理解（二者的区别）

接口（接口的名称一般用大写字母I开头的）是把公共实例（非静态）方法和属性组合起来，以封装特定功能的一个集合。（其实，接口简单理解就是一种约定，使得实现接口的类或结构在形式上保持一致）

注意：使用接口可以使程序更加清晰和条理化，这就是接口的好处，但并不是所有的编程语言都支持接口，C#是支持接口的。注意，虽然在概念上，C#接口类似于COM接口，但他们的底层结构是不同的。那么，我们来看一下如何声明和使用接口。

1.声明接口

　　声明接口在语法上和声明抽象类完全相同，例如这里有一个银行账户的接口：（注意：接口中只能包含方法、属性、索引器和事件的声明。不允许声明成员上的修饰符，即使是pubilc都不行，因为接口成员总是公有的，也不能声明为虚拟和静态的。如果需要修饰符，最好让实现类来声明）

public interface IBankAccount
{
    void PayIn(decimal amount);
    bool Withdraw(decimal amount);

    decimal Balance
    {
        get;
    }
}

2.接口的使用

接口的首要作用是用来类的继承，或者说是统一定义类必要的结构形式。

下面是一个简单的例子，但足以说明接口的使用方法。一个银行账户的接口，两个不同银行账户的实现类，都继承于这个接口。接口声明如上。下面是两个账户类

class SaverAccount : IBankAccount
{
    private decimal balance;

    public decimal Balance
    {
        get
        {
            return balance;
        }
    }

    public void PayIn(decimal amount)
    {
        balance += amount;
    }

    public bool Withdraw(decimal amount)
    {
        if (balance >= amount)
        {
            balance -= amount;
            return true;
        }
        Console.WriteLine("Withdraw failed.");
        return false;
    }

    public override string ToString()
    {
        return String.Format("Venus Bank Saver:Balance={0,6:C}", balance);
    }
}

class GoldAccount : IBankAccount
{
    private decimal balance;

    public decimal Balance
    {
        get
        {
            return balance;
        }
    }

    public void PayIn(decimal amount)
    {
        balance += amount;
    }

    public bool Withdraw(decimal amount)
    {
        if (balance >= amount)
        {
            balance -= amount;
            return true;
        }
        Console.WriteLine("Withdraw failed.");
        return false;
    }

    public override string ToString()
    {
        return String.Format("Jupiter Bank Saver:Balance={0,6:C}", balance);
    }
}

可见，这两个实现类多继承了IBankAccount接口，因此它们必须要实现接口中的所有声明的方法。要不然，编译就会出错。让我们来测试一下，下面是测试代码：

static void Main(string[] args)
{
    IBankAccount venusAccount = new SaverAccount();
    IBankAccount jupiterAccount = new CurrentAccount();
    venusAccount.PayIn(200);
    jupiterAccount.PayIn(500);
    Console.WriteLine(venusAccount.ToString());
    jupiterAccount.PayIn(400);
    jupiterAccount.Withdraw(500);
    jupiterAccount.Withdraw(100);
    Console.WriteLine(jupiterAccount.ToString());

}

在这里特别注意的是：开头两句，我们把它们声明为IBankAccount引用的方式，而没有声明为类的引用，为什么呢？因为，这样我们就可以让它指向执行这个接口的任何类的实例了，比较灵活。但这也有个缺点，如果我们要执行不属于接口的方法，比如这里重载的ToString()方法，就要先把接口的引用强制转换成合适的类型了。接口不能独立存在，不能像实例化一个类那样实例化接口。另外，接口不能包含实现其成员的任何代码，而只能定义成员本身。实现过程必须在实现接口的类中实现。

3.接口间的继承

口也可以彼此继承，就象类的继承一样。比如我们又声明一个接口ITransferBankAccount，它继承于IBankAccount接口。

interface ITransferBankAccount : IBankAccount
{
    bool TransferTo(IBankAccount destination, decimal amount);
}

在这个接口中，又新增加了一个方法TransferTo()，所以如果我们要写一个类从ITransferBankAccount继承的话，就必须要实现IBankAccount和ITransferBankAccount两个接口所有的方法声明。即：

class CurrentAccount : ITransferBankAccount
{
    private decimal balance;

    public decimal Balance
    {
        get
        {
            return balance;
        }
    }

    public void PayIn(decimal amount)
    {
        balance += amount;
    }

    public bool Withdraw(decimal amount)
    {
        if (balance >= amount)
        {
            balance -= amount;
            return true;
        }
        Console.WriteLine("Withdraw failed.");
        return false;
    }

    public override string ToString()
    {
        return String.Format("Jupiter Bank Saver:Balance={0,6:C}", balance);
    }

    public bool TransferTo(IBankAccount destination, decimal amount)
    {
        if (Withdraw(amount))
        {
            destination.PayIn(amount);
            return true;
        }
        else
        {
            return false;
        }
    }
}

总结起来说，使用C#接口应注意几个问题：

　　1、C#中的接口是独立于类来定义的。这与 C++模型是对立的，在 C++中接口实际上就是抽象基类。

　　2、接口和类都可以继承多个接口。

　　3、类可以继承一个基类，接口根本不能继承类。这种模型避免了 C++的多继承问题，C++中不同基类中的实现可能出现冲突。因此也不再需要诸如虚拟继承和显式作用域这类复杂机制。C#的简化接口模型有助于加快应用程序的开发。

　　4、一个接口定义一个只有抽象成员的引用类型。C#中一个接口实际所做的，仅仅只存在着方法标志，但根本就没有执行代码。这就暗示了不能实例化一个接口，只能实例化一个派生自该接口的对象。

　　5、接口可以定义方法、属性和索引。所以，对比一个类，接口的特殊性是：当定义一个类时，可以派生自多重接口，而你只能可以从仅有的一个类派生。

 4.其他（可删除的对象）

IDisposable接口特别有趣，支持IDisposable接口的对象必须实现其Dispose（）方法。当不再需要某个对象时，就可以调用这个方法，释放重要的资源，否则该资源会等到对垃圾回收调用析构函数是才能释放，这样可以更好的控制对象的使用的资源。

第二部分:C# 的继承、派生（基类，父类等）

1.实现继承：

便是一个类型派生于一个基类型，拥有该基类型的多有成员字段和函数。在实现继承中，派生类型的每个函数采用基类型的实现代码，除非在派生类型的定义中指定重写该函数的实现代码。在需要给现有的类型添加功能，或许多相关的类型共享一组重要的公共功能时，这种类型的继承是非常有效的。

2.接口继承：表示一个类型只继承了函数的签名，没有继承任何实现代码。在需要指定该类型具有某些可用的特性时，最好使用这种类型的继承。

public class CFather

        {

            public CFather()

            {

                Console.WriteLine("我是基类CFather");

            }

            //其他成员

        }

        public class CSon : CFather

        {

            public CSon()

            {

                Console.WriteLine("我是CFather的派生类！");

            }

            //其他成员

     }

注意：C#不支持私有继承，因此基类名上没有public或private限定符

3.C# 基类的虚方法的用途

把一个基类函数声明为virtual,该函数就可以在任何派生类中重写了。这同样也适用于属性。C#中可以在派生类中重写虚函数。在调用方法时，会调用对象类型的何时方法。在C#中，函数默认情况下不是虚拟的，但（除了构造函数以外）可以显式的声明为virtual。但是C#要求在派生类的函数重写另一个函数时，要用override关键字显式声明。下面来看一个例子：

public class CFather

        {

            public CFather()

            {

                Console.WriteLine("我是基类CFather");

            }

            virtual public void Fuction()

            {

                Console.WriteLine("Fuction in CFather!");

            }

        }

        public class CSon : CFather

        {

            public CSon()

            {

                Console.WriteLine("我是CFather的派生类！");

            }

            public override void Fuction()

            {

                Console.WriteLine("Function in CSon!");

            }

        }

在Main()函数中：

            CFather a = new CFather();

            CSon b = new CSon();

            a.Fuction();

            b.Fuction();

运行结果如下：

我是基类CFather

我是基类CFather

我是CFather的派生类！

Fuction in CFather!

Function in CSon!

 4. 派生类的构造函数

构造函数的调用顺序是先调用System.Object，再按照层次节后由上向下进行，直到到达编译器要实例化的类为止。还要注意在这个过程中，每个构造函数都初始化自己的类中的字段。构造函数的执行顺序，总是最先调用基类的构造函数。也就是说，派生类的构造函数可以在执行过程中调用基类方法、属性和其他成员，因为基类已经构造出来了，其字段也初始化了。

注意：成员字段和静态函数都不能声明为virtual，因为这个概念只对类中的实例化函数成员有意义。

5.调用函数的基类版本

C#有一种特殊的语法用于从派生类中调用方法的基类版本：base.<MethodName>()

6.抽象类和抽象函数

C#允许把类和函数声明为abstract，抽象类不能实例化，而抽象函数没有执行代码，必须在非抽象的派生类中重写。显然，抽象函数也是虚拟的（但也不需要提供virtual关键字，实际上如果提供了该关键字，就会产生一个语法错误）。如果类包含抽象函数，该类将也是抽象的，也必须声明为抽象的。当然抽象类里也可以声明变量：

abstract class CAbstract

        {

            public abstract void Fuction1(int a);

        }

        class CSon : CAbstract

        {

            public CSon()

            {

            }

            public override void Fuction1(int a)

            {

                Console.WriteLine("{0}", a);

            }

        }

7.密封类和密封方法

C#允许把类和方法声明为sealed。对于类来说，这表示不能继承该类；对于方法来说，这表示不能重写该方法。例如：

 sealedclassClassA

        {

            //方法属性等……
        }

        classClassB : ClassA//这样的继承是错误的！

        {

            //方法属性等……
        }

 C# 中常用的修饰符

1. public

public关键字是类型和类型成员的访问修饰符。公共访问是允许的最高访问级别。对访问公共成员没有限制。

2.private

private关键字是一个成员访问修饰符。私有访问是允许的最低访问级别。私有成员只有在声明它们的类和结构体中才是可访问的。

3.     internal

internal关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中，内部类型或成员才是可访问的。

4.protected

protected关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。.