繼承和多態之間有什麼區別？

Question

你能給我一個簡單的繼承和多態的例子，所以它可以完全清楚和可以理解嗎？我使用C＃會讓它更清晰，因爲我已經學會了。

P.S：導師，書我們已經有了在本地語言（阿拉伯語）

對不起，如果這個問題似乎很簡單，即使是在你們愚蠢的，但這些概念被認爲是硬;如果你不完全瞭解它們，那麼你就會失敗。

Answer 1

讓我們用我最喜歡的動詞，我們發現：

http://en.wikipedia.org/wiki/Polymorphism_%28computer_science%29

http://msdn.microsoft.com/en-us/library/ms173152%28v=vs.80%29.aspx

多態和繼承是關鍵，需要將要-根深蒂固和基本概念，C＃和麪向對象編程。說你知道C＃而不是這就像知道如何說英語，並且沒有關於字母表的概念。對不起，生硬，但它是真的。

從上面的鏈接維基（這不是我的），這裏是多態的例子（轉換爲C＃...）

public class Animal 
{ 
    public virtual String talk() { return "Hi"; } 
    public string sing() { return "lalala"; } 
} 

public class Cat : Animal 
{ 
    public override String talk() { return "Meow!"; } 
} 

public class Dog : Animal 
{ 
    public override String talk() { return "Woof!"; } 
    public new string sing() { return "woofa woofa woooof"; } 
} 

public class CSharpExampleTestBecauseYouAskedForIt 
{ 
    public CSharpExampleTestBecauseYouAskedForIt() 
    { 
     write(new Cat()); 
     write(new Dog()); 
    } 

    public void write(Animal a) { 
     System.Diagnostics.Debug.WriteLine(a.talk()); 
    } 

} 

Answer 2

繼承意味着如果你創建一個類汽車與公共領域TankSize然後你從它派生出一個SuperCar類，最後一個繼承了Car的字段TankSize。

多態性是這樣的一個事實，即每次在代碼中都有一個方法，在這個方法中，Car應該可以通過SuperCar，並且它的行爲就像Car。

根據需要定義虛擬方法，您將在基類上調用方法，但您正在處理的實際對象將執行其虛擬方法的版本，因此您將調用SuperCar.GetPrice而不是Car。事實上GetPrice。

這個用幾句話來說，對於更多，我看到其他人已經在回答我的寫作。

Answer 3

這是多態：

public interface Animal 
{ 
    string Name { get; } 
} 

public class Dog : Animal 
{ 
    public string Name { get { return "Dog"; } } 
} 

public class Cat : Animal 
{ 
    public string Name { get { return "Cat"; } } 
} 

public class Test 
{ 
    static void Main() 
    { 
     // Polymorphism 
     Animal animal = new Dog(); 

     Animal animalTwo = new Cat(); 

     Console.WriteLine(animal.Name); 
     Console.WriteLine(animalTwo.Name); 
    } 
} 

這是繼承：

public class BaseClass 
    { 
     public string HelloMessage = "Hello, World!"; 
    } 

    public class SubClass : BaseClass 
    { 
     public string ArbitraryMessage = "Uh, Hi!"; 
    } 

    public class Test 
    { 
     static void Main() 
     { 
      SubClass subClass = new SubClass(); 

      // Inheritence 
      Console.WriteLine(subClass.HelloMessage); 
     } 
    } 

Answer 4

讓我們以更有趣的方式解釋。繼承是派生類使用基類功能的方式。 多態是基類使用派生類實現的方式。

public class Triangle :Shape { 
public int getSides() { 
    return 3; 
} 
} 

} 
public class Shape { 
public boolean isSharp(){ 
    return true; 
} 
public virtual int getSides(){ 
    return 0 ; 
} 

public static void main() { 
    Triangle tri = new Triangle(); 
    System.Console.WriteLine("Triangle is a type of sharp? " + tri.isSharp()); //Inheritance 
    Shape shape = new Triangle(); 
    System.Console.WriteLine("My shape has " + shape.getSides() + " sides."); //Polymorphism 
} 
} 

Answer 5

繼承和多態之間沒有區別。多態是繼承的一部分，沒有它，就不可能存在。簡而言之，多態是一種將對象視爲基類對象的能力，但在基類上調用VIRTUAL方法將從子類調用適當的方法。很好的例子是：http://www.psworld.pl/Programming/Inheritance

Answer 6

當你從基類派生一個類時，派生類將繼承基類的所有成員，除了構造函數，儘管派生類是否能夠訪問這些成員將取決於這些成員在基類中的可訪問性。 C＃通過繼承爲我們提供了多態性。基於繼承的多態允許我們在基類中定義方法，並用派生類實現覆蓋它們。因此，如果您有一個可能持有多個派生類對象之一的基類對象，正確使用時的多態性允許您根據對象所屬派生類的類型調用一個工作方式不同的方法。

參考：http://www.codeproject.com/Articles/1445/Introduction-to-inheritance-polymorphism-in-C

Answer 7

多態性是壓倒一切的，你繼承了什麼行爲。

如果你不覆蓋它，它不是多態，它只是繼承。

Answer 8

這一切都是關於行爲。

甲類聲明某種行爲（接口或合同）：

即類還可以定義行爲（實現）或代表任一的全部或它的一部分，以它的任何子類：

在僞代碼：

class Animal { 
    method walk() 
    method speak() 
    method jump() 
    // ... here goes the implementation of the methods 
} 

通過繼承你犯了一個類繼承另一類的行爲。

當一個方法的執行被委託給子類，該方法被調用基類抽象，在像Java這樣的語言，整個基類成爲抽象的，以及：

abstract class Animal { 
    method walk() { 
     doWalk() 
    } 
    method speak() { 
     print "hi, I am an animal!" 
    } 
    abstract method jump() // delegated to specific animals 
} 

class Horse inherits from Animal { 
    override method walk() { 
     doWalkLikeAHorse() 
    } 
    override method speak() { 
     print "hi, I am a horse!" 
    } 
    override method jump() { 
     doJumpLikeAHorse() 
    } 
} 

class Elephant inherits from Animal { 
    override method walk() { 
     doWalkLikeAnElephant() 
    } 
    override method speak() { 
     print "hi, I am an elephant!" 
    } 
    override method jump() { 
     throw error "Sorry, I can't jump!!" 
    } 
} 

一類'的行爲默認爲虛擬，這意味着任何類方法都可能被任何子類覆蓋。例如，這就是它在C＃和Java等語言中的工作方式，但不一定在C++中。

在物質，基類的行爲僅僅是虛擬的和可以假設「多重」（聚）「不同的形式」（搖身一變）當子類重寫該虛擬行爲。這就是爲什麼它被稱爲多態性。在僞代碼：

function makeAnimalSpeak(Animal animal) { 
    animal.speak(); 
} 

makeAnimalSpeak(new Elephant()) // output: "hi, I am an elephant" 
makeAnimalSpeak(new Horse()) // output: "hi, I am a horse" 

其他人在這裏提供了更好的例子。

在C＃和Java等語言中，您有接口（C++中不存在）的想法，這只是行爲的聲明。與類不同，接口沒有義務實施行爲。這只是一個聲明。任何類都可以實現該行爲，而不管它們從哪個基類繼承。在僞代碼：

interface FlyingBeing { 
    method fly() 
} 

class FlyingPig inherits from Animal implements FlyingBeing { 
    method fly() { 
     print "hey, look at me, I am a flying pig!!" 
    } 
}