混淆關於界面

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