继承和多态之间有什么区别？

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!!" 
    } 
}