混淆关于界面

Question

我在C＃中很新。 现在阅读Interfaces。我很困惑。我读过MSDN，我们不能直接实例化接口。后来他们写了下面的例子。

Public interface ICat 
{ 
    meow(); 
} 
Public class Cat : ICat 
{ 
    meow(){//do something } 
} 
//////////////////// 
static void main(){ 
Icat cat = new Cat(); 
Cat cat1 = nes Cat(); 
} 

如果我们不能直接实例化的接口，那么究竟是什么这行Icat cat = new Cat();意义。 这两者有什么区别？

Answer 1

两行实例化Cat类的实例。不同的是，其中一个被分配到变量类型为ICat。

ICat cat = new Cat(); 
Cat cat1 = nes Cat(); 

因为你只能调用通过cat变量访问Cat例如，当上ICat声明的方法的。当使用cat1时，您可以访问Cat课程的其他成员。

如果您对任何变量调用GetType，您将收到Cat，因为这是您拥有的实例的类型。

的另一个区别是，如果有实现ICat另一个类，你可以指定它的实例来cat变量，但你不能把它分配给cat1除非它继承Cat：

Public class OtherCat : ICat 
{ 
    meow(){//do something } 
} 

cat = new OtherCat(); 
// cat1 = new OtherCat(); // fails 

Answer 2

第一个示例中的接口没有被实例化，而是实例化的Cat()实例的类型被声明为类型ICat而不是Cat。

在你的具体例子中，这不是很有趣。然而，考虑到了以下声明的接口：一旦这个接口被应用到多个具体类型

public interface ICat 
{ 
    Meow(); 
    Run(); 
    Hunt(); 
} 

，行为可以在各种类应用，同时始终贯彻相同的行为。

public class Lion : ICat 
{ 
    public void Roar(); 
    public void Meow(); 
    public void Run(); 
    public void Hunt(); 
} 

public class Tiger : ICat 
{ 
    public void Meow(); 
    public void Run(); 
    public void Hunt(); 
} 

ICat lion = new Lion(); 
ICat tiger = new Tiger(); 

两个具体事例可以受益于接口只有靠接口担保，除非铸造自己的具体类型的方法保证所有这三种方法。这提供了跨行为的一致性。但是请注意，这不是实例化接口。它只是将具体实例分配给语言允许的共享接口类型。

结果：

lion.Run();和tiger.Run()都是完全允许的。

然而，

lion.Roar()不会编译，因为它不是由接口保证。也就是说，如果转换为实际实例化并随后分配给接口的基础具体类型，则除了接口的方法外，还可以访问该类型的方法。

((Lion)lion).Roar(); 

同样：实例化时

Lion concreteLion = new Lion(); 

没有分配到的接口。因此它可以直接访问接口保证的所有三种方法，并且可以在不需要转换的情况下调用concreteLion.Roar()，因为实例已直接分配给具体类型而不是由Lion类实现的接口。

Answer 3

我觉得对我来说最好的说明是这样的：

public interface IAnimal 
{ 
    void ShowVoice(); 
} 

public class Cat : IAnimal 
{ 
    public void WiggleTail() 
    { 
     Console.Write("Wiggling tail...") 
    } 

    public void ShowVoice() 
    { 
     Console.Write("meow"); 
    } 
} 

public class Dog : IAnimal 
{ 
    public void GivePaw() 
    { 
     Console.Write("Giving paw...") 
    } 
    public void ShowVoice() 
    { 
     Console.Write("woof"); 
    } 
} 

public static void main(){ 
    IAnimal cat = new Cat(); 
    IAnimal dog = nes Dog(); 
    cat.ShowVoice(); 
    //cat.WiggleTail(); - cannot do that on interface 
    dog.ShowVoice(); 
    //dog.GivePaw(); - cannot do that on interface 
    Cat catInst = new Cat(); 
    Dog dogInst = new Dog(); 
    catInst.WiggleTail(); // you can do that because it is not an interface that we make call to 
    dogInst.GivePaw(); //the same as with cat 
    // catInst.GivePaw(); - cannot do this because it does not exist in the class 
} 

Answer 4

当我们定义一个接口，我们定义了一个通用的情况下，当一个类实现了接口，那么我们定义SPE案例。 让我们举例

interface IVehicle 
{ 
    int noOfWheels; 
    float price; 
} 

class TwoWheeler : IVehicle 
{ 
    public TwoWheeler(float price) 
    { 
     this.noOfWheels = 2; 
     this.price = price; 
    } 
} 

class FourWheeler : IVehicle 
{ 
    public FourWheeler(float price) 
    { 
     this.noOfWheels = 4; 
     this.price = price; 
    } 
} 

class VehicleBill 
{ 
    IVehicle vehicle; 

    public static void main() 
    { 
     Console.Write("enter your choice 
       \n 1. Two wheeler 
       \n 2. Four Wheeler"); 
     int ch = Conver.toInt32(console.Read()); 

    //Here we decide which class is to be used for initialization 
     if(ch == 1) 
     vehicle = TwoWheeler(80000); 
    else if(ch == 2) 
     vehicle = FourWheeler(500000); 
    } 
} 

Answer 5

首先，我们定义一个interface是什么。

可以认为interface与合同相同，因为类必须实现给定接口（合约）中定义的任何内容。例如，假设我正在设计一个interface来定义汽车的行为。

该接口将包含两个关键行为。

1. 加快
2. 制动

例

public interface ICar 
{ 
    void Accelerate(); 
    void Brake(); 
} 

你永远不能实例化一个interface因为interface只是一个合约，各种什么class绝的定义执行，class从派生将实现它所源自的interface中定义的所有属性和方法。如本答案中所示，Interfaces通常用于减少代码库中的依赖关系。

继续上面的例子，人类驾驶汽车，但是有数千辆不同的汽车在那里，而且大多数都是以不同的方式实施的，但是，如果你有能力驾驶一辆车，你应该可以驾驶所有的汽车。 （只是在这里概括一下，以保持简单）。

因此，你需要做的就是实例化一个class实现了ICarinterface任何人都可以再取一个驱动器...

void Main() 
{ 
    Human jamesDoe = new Human(); 
    ICar car = new BMW(); 

    jamesDoe.TestDriveCar(car); 
} 

public interface ICar 
{ 
    void Accelerate(); 
    void Brake(); 
} 

public class BMW : ICar 
{ 
    private int x; 

    public void Accelerate() 
    { 
     new int[150].ToList() 
        .ForEach(i => { Console.WriteLine("{0} MPH", x++); Thread.Sleep(50); }); 

    } 
    public void Brake() 
    { 
     new int[150].ToList() 
        .ForEach(i => { Console.WriteLine("{0} MPH", x--); Thread.Sleep(50); }); 
    } 
} 

public class Human 
{ 
    public void TestDriveCar(ICar car) 
    { 
     car.Accelerate(); 
     car.Brake(); 
    } 
}