blocks|key|653787|text|主要的区别是多态性是遗传的特定结果。多态性是在运行时根据对象的类型确定要调用的方法。当一个类继承了另一个类并覆盖了一个特定的方法时，就会出现这种情况。然而，在普通的继承树中，您不必覆盖任何方法，因此并不是所有的方法调用都必须是多态的。这有意义吗？这是一个类似的问题，所有的福特汽车都是汽车，但并不是所有的汽车都是福特(尽管不完全是……)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|653788|此外，多态性处理方法调用，而继承也描述数据成员等。|653789|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The main difference is polymorphism is a specific result of inheritance. Polymorphism is where the method to be invoked is determined at runtime based on the type of the object. This is a situation that results when you have one class inheriting from another and overriding a particular method. However, in a normal inheritance tree, you don't have to override any methods and therefore not all method calls have to be polymorphic. Does that make sense? It's a similar problem to all Ford vehicles are automobiles, but not all automobiles are Fords (although not quite....).

Additionally, polymorphism deals with method invocation whereas inheritance also describes data members, etc.

blocks|key|871165|text|继承是当类A从它的所有父对象继承所有非静态的受保护的/公共的方法/字段时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871166|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Inheritance is when class A inherits all nonstatic protected/public methods/fields from all its parents till Object.

blocks|key|871239|text|多态性是一种表达具有相似特征的对象类型之间的共同行为的方法。它还允许通过覆盖来创建这些特征的变体。继承是一种通过对象层次结构实现多态性的方法，其中对象表示关系和抽象行为。不过，这并不是实现多态性的唯一方法。原型是另一种表达多态性的方式，它不同于继承。JavaScript是使用prototype的语言的一个例子。我想还有其他的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871240|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Polymorphism is an approach to expressing common behavior between types of objects that have similar traits. It also allows for variations of those traits to be created through overriding. Inheritance is a way to achieve polymorphism through an object hierarchy where objects express relationships and abstract behaviors. It isn't the only way to achieve polymorphism though. Prototype is another way to express polymorphism that is different from inheritance. JavaScript is an example of a language that uses prototype. I'd imagine there are other ways too.

blocks|key|654025|text|继承更多的是静态的东西(一个类扩展了另一个类)，而多态性是动态的/运行时的东西(一个对象根据它的动态/运行时类型而不是它的静态/声明类型来行为)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654026|例如。|654027|//+This+assignment+is+possible+because+B+extends+A
A+a+=+new+B();
//+polymorphic+call/+access
a.foo();|code-block|syntax|javascript|654028|->虽然a的静态/声明类型是A，但实际的动态/运行时类型是B，因此a.foo()将按照B而不是A中的定义执行foo。|654029|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Inheritance is more a static thing (one class extends another) while polymorphism is a dynamic/ runtime thing (an object behaves according to its dynamic/ runtime type not to its static/ declaration type).

E.g.

<pre><code>// This assignment is possible because B extends A
A a = new B();
// polymorphic call/ access
a.foo();
</code></pre>

-> Though the static/ declaration type of a is A, the actual dynamic/ runtime type is B and thus a.foo() will execute foo as defined in B not in A.

blocks|key|654121|text|在Java中，这两者密切相关。这是因为Java使用了一种称为“动态调度”的方法调用技术。如果我有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654122|public+class+A+{
++public+void+draw()+{+...+}
++public+void+spin()+{+...+}
}

public+class+B+extends+A+{
++public+void+draw()+{+...+}
++public+void+bad()+{+...+}
}

...

A+testObject+=+new+B();

testObject.draw();+//+calls+B's+draw,+polymorphic
testObject.spin();+//+calls+A's+spin,+inherited+by+B
testObject.bad();+//+compiler+error,+you+are+manipulating+this+as+an+A|code-block|syntax|javascript|654123|然后，我们看到B从A继承了spin。然而，当我们试图操作对象时，就好像它是一个类型A一样，我们仍然得到了B对draw的行为。draw行为是多态的。|offset|length|style|CODE|654124|在某些语言中，多态性和继承没有那么紧密地联系在一起。例如，在C%2B%2B中，未声明为虚的函数是继承的，但不会动态分派，因此即使使用继承也不会获得多态行为。|654125|在javascript中，每个函数调用都是动态分派的，这样你就有了弱类型。这意味着您可以有一堆不相关的对象，每个对象都有自己的draw，有一个函数迭代它们并调用该函数，每个对象的行为都很好。您将拥有自己的多态绘图，而不需要继承。|654126|entityMap^0|0|0|D|4|1I|4|1Q|4|0|0|1R|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

In Java, the two are closely related. This is because Java uses a technique for method invocation called "dynamic dispatch". If I have

<pre><code>public class A {
 public void draw() { ... }
 public void spin() { ... }
}

public class B extends A {
 public void draw() { ... }
 public void bad() { ... }
}

...

A testObject = new B();

testObject.draw(); // calls B's draw, polymorphic
testObject.spin(); // calls A's spin, inherited by B
testObject.bad(); // compiler error, you are manipulating this as an A
</code></pre>

Then we see that B inherits <code>spin</code> from A. However, when we try to manipulate the object as if it were a type A, we still get B's behavior for <code>draw</code>. The <code>draw</code> behavior is polymorphic.

In some languages, polymorphism and inheritance aren't quite as closely related. In C++, for example, functions not declared virtual are inherited, but won't be dispatched dynamically, so you won't get that polymorphic behavior even when you use inheritance. 

In javascript, every function call is dynamically dispatched and you have weak typing. This means you could have a bunch of unrelated objects, each with their own <code>draw</code>, have a function iterate over them and call the function, and each would behave just fine. You'd have your own polymorphic draw without needing inheritance.

blocks|key|654195|text|多态性:假设你在一家销售钢笔的公司工作。所以你创建了一个非常好的类，叫做"+pen“，它处理了你需要知道的关于笔的所有事情。您可以编写各种用于计费、运输、开具发票的类，所有这些都使用Pen类。一天，老板来了，他说：“好消息！公司正在发展，我们现在开始卖书和CD了！”这不是个好消息，因为现在你必须更改每个使用Pen的类，使其也使用Book+&+CD。但是，如果您最初创建了一个名为"SellableProduct“的接口，并且Pen实现了此接口，会发生什么呢？然后，您可以编写所有的发货、发票等类来使用该接口，而不是Pen。现在，您需要做的就是创建一个名为Book+&+CompactDisc的新类，该类实现SellableProduct接口。由于多态，所有其他类都可以继续工作，而不需要更改！讲得通?|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654196|因此，这意味着使用继承，这是实现多态性的一种方式。|654197|多态可以在一个类/接口中实现，但继承总是在两个或更多个类/接口之间进行。继承总是符合"+is+-a“关系，而它并不总是符合多态性(它可以符合"is-a”/+"has-a“关系。|654198|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Polymorphism:
Suppose you work for a company that sells pens. So you make a very nice class called "Pen" that handles everything that you need to know about a pen. You write all sorts of classes for billing, shipping, creating invoices, all using the Pen class. A day boss comes and says, "Great news! The company is growing and we are selling Books &amp; CD's now!" Not great news because now you have to change every class that uses Pen to also use Book &amp; CD. But what if you had originally created an interface called "SellableProduct", and Pen implemented this interface. Then you could have written all your shipping, invoicing, etc classes to use that interface instead of Pen. Now all you would have to do is create a new class called Book &amp; CompactDisc which implements the SellableProduct interface. Because of polymorphism, all of the other classes could continue to work without change! Make Sense?

So, it means using Inheritance which is one of the way to achieve polymorphism.

Polymorhism can be possible in a class / interface but Inheritance always between 2 OR more classes / interfaces. Inheritance always conform "is-a" relationship whereas it is not always with Polymorphism (which can conform both "is-a" / "has-a" relationship.

blocks|key|871611|text|如果你使用JAVA，它就像这样简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871612|多态是使用继承的方法，但“覆盖”它们来做一些不同的事情(或者，如果你调用super，从技术上讲也不是多态的)。|871613|如果我错了，请纠正我。|871614|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If you use JAVA it's as simple as this:

Polymorphism is using inherited methods but "Overriding" them to do something different (or the same if you call super so wouldn't technically be polymorphic).

Correct me if I'm wrong.

blocks|key|871674|text|继承是一个与代码重用相关的概念。例如，如果我有一个父类，假设是Animal，它包含某些属性和方法(在本例中是makeNoise()和sleep())，我创建了两个子类，分别称为Dog和Cat。由于狗和猫都以相同的方式入睡(我假设如此)，因此不需要在父类Animal提供的Dog和Cat子类中的sleep()方法中添加更多功能。但是，Dog会叫，Cat会叫，所以尽管Animal类可能有一种制造噪音的方法，但狗和猫相对于彼此和其他动物发出不同的噪音。因此，需要为其特定类型重新定义该行为。于是就有了多态性的定义。希望这能有所帮助。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|871675|entityMap^0|V|6|1I|B|1U|7|2G|3|2K|3|3I|6|3R|3|3V|3|42|7|4M|3|4S|3|52|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|G|$]]

Inheritance is a concept related to code reuse. For example if I have a parent class say <code>Animal</code> and it contains certain attributes and methods (for this example say <code>makeNoise()</code> and <code>sleep()</code>) and I create two child classes called <code>Dog</code> and <code>Cat</code>. Since both dogs and cats go to sleep in the same fashion( I would assume) there is no need to add more functionality to the <code>sleep()</code> method in the <code>Dog</code> and <code>Cat</code> subclasses provided by the parent class <code>Animal</code>. However, a <code>Dog</code> barks and a <code>Cat</code> meows so although the <code>Animal</code> class might have a method for making a noise, a dog and a cat make different noises relative to each other and other animals. Thus, there is a need to redefine that behavior for their specific types. Thus the definition of polymorphism. Hope this helps.

blocks|key|654401|text|继承是一种多态，实际上继承就是动态多态。所以，当你移除继承时，你不能再重写了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654402|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

inheritance is kind of polymorphism, Exactly in fact inheritance is the dynamic polymorphism. So, when you remove inheritance you can not override anymore.

I was presented with this question in an end of module open book exam today and found myself lost. I was reading <code>Head first Java</code>and both definitions seemed to be exactly the same. I was just wondering what the MAIN difference was for my own piece of mind. I know there are a number of similar questions to this but, none I have seen which provide a definitive answer.

What is the main difference between Inheritance and Polymorphism?

Java

在今天的模块开卷考试结束时，我遇到了这个问题，我发现自己迷失了方向。我正在读Head first Java，这两个定义似乎完全相同。我只是想知道我自己的想法的主要区别是什么。我知道有许多类似的问题，但我还没有看到一个明确的答案。

问遗传和多态性之间的主要区别是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问遗传和多态性之间的主要区别是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问遗传和多态性之间的主要区别是什么？
EN