基础拾遗------接口详解

时间 2019-11-09

标签基础拾遗接口详解繁體版

原文原文链接

基础拾遗：

基础拾遗------特性详解html

基础拾遗------webservice详解web

基础拾遗------redis详解redis

基础拾遗------反射详解数据结构

基础拾遗------委托详解ide

基础拾遗------接口详解函数

基础拾遗------泛型详解工具

基础拾遗-----依赖注入spa

基础拾遗-----数据注解与验证设计

基础拾遗-----mongoDB操做code

基础拾遗----RabbitMQ

　　接口定义了全部类继承接口时应遵循的契约。接口定义了 "要什么" ，派生类定义了 "怎么给" 。

　引用CLR VIA C#（类和接口继承）

　　在Microsoft.Net Framwork中，有一个名为System.Object的类，它定义了4个公共实例方法：ToString, Equals, GetHashCode和GetType。该类是其余全部类的根或者说最终基类。换言之，全部类都继承了Object的4个实例方法。这还意味着能操做 Object类的实例的代码实际能操做任何类的实例。

　　在CLR中，任何类都确定从一个类也只能从一个类(并且只能从Objetc派生的类)派生的。这个类称为基类。基类提供了一组方法签名和这些方法的实现。你定义的新类可在未来由其它开发人员用做基类——全部方法签名和方法实现都会由新的派生类继承。

　　CLR容许开发人员定义接口，它实际只是对一组方法签名进行了统一的命名。这些方法没有提供任何实现。类经过指定接口与名称来实现这个接口，它必须显式提供接口方法的实现，不然CLR会认为此类型定义无效。

　　类继承有一个重要特色，凡是能使用基类型实例的地方，都能使用派生类型的实例。相似的，凡是能使用具备接口类型实例的地方，都能使用实现了这个接口的一个类型的实例。

1.接口的特性

　　1.1.接口是一个引用类型，经过接口能够实现多重继承。

　　1.2.接口成员是自动公开的(public)，且不能包含任何访问修饰符(public、protected、internal、private),不然编译器会报错。

　　1.3.接口相似于抽象基类，不能直接实例化接口；接口中的方法都是抽象方法，实现接口的任何非抽象类型都必须实现接口的全部成员:

　　　　当显式实现该接口的成员时，实现的成员不能经过类实例访问，只能经过接口实例访问。

　　　　当隐式实现该接口的成员时，实现的成员能够经过类实例访问，也能够经过接口实例访问，可是实现的成员必须是公有的。

　　1.4.接口不能包含常量、字段、运算符、实例构造函数、析构函数或类型、不能包含静态成员,只能包含方法、属性、事件、索引等成员。

　　1.5.接口成员不能有static、abstract、override、virtual修饰符，使用new修饰符不会报错，但会给出警告说不须要关键字new。

　　1.6.在声明接口成员的时候，不许为接口成员编写具体的可执行代码，也就是说，只要在对接口进行声明时指明接口的成员名称和参数就能够了。

2.接口与抽象类

2.1下面让咱们来对接口与抽象类作个对比。若有不一样意见欢迎讨论。

	interface	abstract class
实例化	不能够	不能够
派生类实现	必须实现全部契约	实现没实现的方法
继承	接口支持多继承	必须抽象类不能实现多继承
抽象	接口只能定义抽象规则	抽象类既能够定义规则，还可能提供已实现的成员。但不能使用new关键字，也不能被密封，缘由是抽象类不能被实例化
概念	接口是一组行为规范	抽象类是一个不彻底的类
回调	接口能够用于支持回调	抽象类不能实现回调，由于继承不支持
成员	接口只包含方法、属性、索引器、事件的签名，但不能定义字段和包含实现的方法	抽象类能够定义字段、属性、包含有实现的方法
数据类型	接口能够做用于值类型和引用类型。例如，Struct就能够继承接口，而不能继承类	抽象类只能做用于引用类型
构造方法	没有构造方法	有构造方法
静态方法	没有静态方法（默认public static final类型）	包含静态方法
修饰符	默认public没有其余修饰符。	能够是public，protected

2.2.抽象类和接口的使用：

2.2.1. 若是预计要建立组件的多个版本，则建立抽象类。抽象类提供简单的方法来控制组件版本；

2.2.2.若是建立的功能将在大范围的全异对象间使用，则使用接口。若是要设计小而简练的功能块，则使用接口；

2.2.3.若是要设计大的功能单元，则使用抽象类.若是要在组件的全部实现间提供通用的已实现功能，则使用抽象类；

2.2.4.抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。

3.接口声明

　　3.1.接口使用 interface 关键字声明，它与类的声明相似。接口声明默认是 public 的；

　　3.2.根据约定，接口类型名称要以大写字母I开头;

public interface ITransactions
{
   // 接口成员
   void showTransaction();
   double getAmount();
}

注：3.3.对CLR而言，定义接口就像定义类型，也就是说，CLR会为接口类型对象定义一个内部数据结构，同时可用反射机制来查询接口类型的功能。

　　3.4.为何不能指定接口中方法的修饰符？

　　　　接口中的方法用来定义对象之间通讯的契约，指定接口中的方法为私有或保护没有意义。它们默认为公有方法。

4.接口的实现

　　C#中的接口提供了一种实现运行时的多态。

　4.1.案例

using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace InterfaceApplication
{

   public interface ITransactions
   {
      // 接口成员
      void showTransaction();
      double getAmount();
   }
   public class Transaction : ITransactions
   {
      private string tCode;
      private string date;
      private double amount;
      public Transaction()
      {
         tCode = " ";
         date = " ";
         amount = 0.0;
      }
      public Transaction(string c, string d, double a)
      {
         tCode = c;
         date = d;
         amount = a;
      }
      public double getAmount()
      {
         return amount;
      }
      public void showTransaction()
      {
         Console.WriteLine("Transaction: {0}", tCode);
         Console.WriteLine("Date: {0}", date);
         Console.WriteLine("Amount: {0}", getAmount());

      }

   }
   class Tester
   {
      static void Main(string[] args)
      {
         Transaction t1 = new Transaction("001", "8/10/2012", 78900.00);
         Transaction t2 = new Transaction("002", "9/10/2012", 451900.00);
         t1.showTransaction();
         t2.showTransaction();
         Console.ReadKey();
      }
   }
}

　　当上面的代码被编译和执行时，它会产生下列结果：

Transaction: 001
Date: 8/10/2012
Amount: 78900
Transaction: 002
Date: 9/10/2012
Amount: 451900

4.2接口的隐式实现与显示实现

　　4.2.1隐式实现

  interface IAnimal
　　　　{
　　　　　　　void Dog();
　　　　}
　　　　class Animal:IAnimal
　　　　{
　　　　　　public void Dog()
　　　　　　{
　　　　　　　//#
　　　　　　}
　　　　 }

　　　　//经过类调用
　　　　Animal animal = new Animal();
　　　　animal.Dog();
　　　　//或者经过接口调用
　　　　IAnimal animal = new Animal();
　　　　animal.Dog();

以上:类与接口都能调用的为隐式实现。

　　4.2.2.显示实现

interface IAnimal
　　{
　　　　void Dog();
　　}
　　class Animal:IAnimal
　　{
　　　　void IAnimal.Dog()
　　　　{
　　　　　　//#
　　　　}
　　}

IAnimal animal = new Animal();
animal.Dog();

Animal animal = new Animal();
(animal as IAnimal).Dog();

以上：用类的方法调用须要强制转换的实现为显示实现。

是否是感受显示实现多余项目中也历来未曾遇到过？？？

4.3.接口隐式实现，显示实现的场景

　　 4.3.1.当类实现一个接口时，一般使用隐式接口实现，这样能够方便的访问接口方法和类自身具备的方法和属性。

　　 4.3.2.当类实现多个接口时，而且接口中包含相同的方法签名，此时使用显式接口实现。即便没有相同的方法签名，仍推荐使用显式接口，由于能够标识出哪一个方法属于哪一个接口。

　　 4.3.3隐式接口实现，类和接口均可访问接口中方法。显式接口实现，只能经过接口访问。

5.接口的继承

　5.1.接口继承和类继承不一样：

　　　　5.1.1.类继承不只是说明继承，并且也是实现继承；而接口继承只是说明继承。

　　　　5.1.2.C#中类继承只容许单继承，可是接口继承容许多继承，一个子接口能够有多个父接口(用","分割)。

　　5.2.接口的继承也造成接口之间的层次结构

 interface IProgram
    {
        void Fun();
    }
    interface IAProgram:IProgram
    {
        
    }
    class Program :  IAProgram
    {
        void IProgram.Fun()
        {
            Console.WriteLine("I am IProgram Fun.");
        }
        staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IAProgram)pro).Fun();
            Console.Read();
        }
    }

6.接口的覆盖

　　经过接口，能够指定组件必须实现的方法，但不实际指定如何实现方法。抽象类能够建立行为的定义，同时提供用于继承类的一些公共实现。对于在组件中实现多态行为，接口和抽象类都是颇有用的工具。

　　如今咱们把一个抽象类被容许把接口方法映射到抽象方法中：

interface ICompute
    {
        void Add();
        void Subtract();
    }

abstract class Compute  : ICompute
{
    void ICompute.Add() { ComputeAdd(); }
    void ICompute.Subtract() { ComputeSubtract(); }
    protected abstract void ComputeAdd();
    protected abstract void ComputeSubtract();
}

　　这里，从Compute派生的非抽象类要覆盖ComputeAdd和 ComputeSubtract，所以提供了ICompute的实际实现程序。

7.接口泛型

很少说：基础拾忆------泛型详解