blocks|key|3365515|text|术语重载指的是具有相同名称的多个版本，通常是具有不同参数列表的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3365516|public+int+DoSomething(int+objectId)+{+...+}
public+int+DoSomething(string+objectName)+{+...+}|code-block|syntax|javascript|3365517|因此，这些函数可能会做同样的事情，但您可以选择使用ID或名称调用它。与继承、抽象类等无关。|3365518|覆盖通常指的是多态性，正如您在问题中所描述的那样|3365519|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The term overloading refers to having multiple versions of something with the same name, usually methods with different parameter lists

<pre><code>public int DoSomething(int objectId) { ... }
public int DoSomething(string objectName) { ... }
</code></pre>

So these functions might do the same thing but you have the option to call it with an ID, or a name. Has nothing to do with inheritance, abstract classes, etc.

Overriding usually refers to polymorphism, as you described in your question

blocks|key|3152694|text|你说得对，重载不是解决问题的办法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3152695|这两个都不是最重要的。覆盖是获得多态的方法。多态性是对象根据其类型改变行为的能力。当呈现多态性的对象的调用者不知道该对象是什么特定类型时，这一点得到了最好的证明。|3152696|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|$]]

You are correct that overloading is not the answer.

Neither is overriding. Overriding is the means by which you get polymorphism. Polymorphism is the ability for an object to vary behavior based on its type. This is best demonstrated when the caller of an object that exhibits polymorphism is unaware of what specific type the object is.

blocks|key|362574|text|重载是指您定义了两个名称相同但参数不同的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362575|重写是通过在子类中使用相同名称的函数来更改基类的行为。|362576|所以多态与重载相关，但并不是真正的重载。|362577|然而，如果有人给我一个简单的答案，“覆盖”的问题“什么是多态性？”我会要求进一步的解释。|362578|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

overloading is when you define 2 methods with the same name but different parameters

overriding is where you change the behavior of the base class via a function with the same name in a subclass.

So Polymorphism is related to overriding but not really overloading.

However if someone gave me a simple answer of "overriding" for the question "What is polymorphism?" I would ask for further explanation.

blocks|key|361988|text|多态性是对象以多种形式出现的能力。这涉及到使用继承和虚拟函数来构建可互换的对象族。基类包含虚拟函数的原型，可能是未实现的，也可能是应用程序指定的默认实现，并且各个派生类都以不同的方式实现它们，以影响不同的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|361989|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 the ability for an object to appear in multiple forms. This involves using inheritance and virtual functions to build a family of objects which can be interchanged. The base class contains the prototypes of the virtual functions, possibly unimplemented or with default implementations as the application dictates, and the various derived classes each implements them differently to affect different behaviors.

blocks|key|360636|text|经典的例子，狗和猫都是动物，动物都有makeNoise方法。我可以遍历对它们调用makeNoise的动物数组，并期望它们分别执行相应的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360637|调用代码不必知道它们是什么特定的动物。|360638|这就是我所认为的多态性。|360639|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|$]]

The classic example, Dogs and cats are animals, animals have the method makeNoise. I can iterate through an array of animals calling makeNoise on them and expect that they would do there respective implementation.

The calling code does not have to know what specific animal they are.

Thats what I think of as polymorphism.

blocks|key|362616|text|下面是伪C#/Java中的多态性示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362617|class+Animal
{
++++abstract+string+MakeNoise+();
}

class+Cat+:+Animal+{
++++string+MakeNoise+()+{
++++++++return+"Meow";
++++}
}

class+Dog+:+Animal+{
++++string+MakeNoise+()+{
++++++++return+"Bark";
++++}
}

Main+()+{
+++Animal+animal+=+Zoo.GetAnimal+();
+++Console.WriteLine+(animal.MakeNoise+());
}|code-block|syntax|javascript|362618|Main函数不知道动物的类型，并依赖于MakeNoise()方法的特定实现行为。|362619|编辑:看起来Brian比我先一步出击。有趣的是，我们使用了相同的示例。但上面的代码应该有助于澄清概念。|362620|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's an example of polymorphism in pseudo-C#/Java:

<pre><code>class Animal
{
 abstract string MakeNoise ();
}

class Cat : Animal {
 string MakeNoise () {
 return "Meow";
 }
}

class Dog : Animal {
 string MakeNoise () {
 return "Bark";
 }
}

Main () {
 Animal animal = Zoo.GetAnimal ();
 Console.WriteLine (animal.MakeNoise ());
}
</code></pre>

The Main function doesn't know the type of the animal and depends on a particular implementation's behavior of the MakeNoise() method.

Edit: Looks like Brian beat me to the punch. Funny we used the same example. But the above code should help clarify the concepts.

blocks|key|362622|text|重写和重载都是用来实现多态性的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362623|在一个或多个子类中，可以有一个被覆盖的类中的方法。根据用于实例化对象的类的不同，该方法执行不同的操作。|offset|length|style|BOLD|362624|++++abstract+class+Beverage+{
+++++++boolean+isAcceptableTemperature();
++++}

++++class+Coffee+extends+Beverage+{
+++++++boolean+isAcceptableTemperature()+{+
+++++++++++return+temperature+>+70;
+++++++}
++++}

++++class+Wine+extends+Beverage+{
+++++++boolean+isAcceptableTemperature()+{+
+++++++++++return+temperature+<+10;
+++++++}
++++}|code-block|syntax|javascript|362625|您还可以有一个方法，它是具有两个或多个参数集的重载的。该方法根据传递的参数类型做不同的事情。|362626|++++class+Server+{
++++++++public+void+pour+(Coffee+liquid)+{
++++++++++++new+Cup().fillToTopWith(liquid);
++++++++}

++++++++public+void+pour+(Wine+liquid)+{
++++++++++++new+WineGlass().fillHalfwayWith(liquid);
++++++++}

++++++++public+void+pour+(Lemonade+liquid,+boolean+ice)+{
++++++++++++Glass+glass+=+new+Glass();
++++++++++++if+(ice)+{
++++++++++++++++glass.fillToTopWith(new+Ice());
++++++++++++}
++++++++++++glass.fillToTopWith(liquid);
++++++++}
++++}|362627|entityMap^0|0|G|3|0|0|N|3|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Both overriding and overloading are used to achieve polymorphism. 

You could have a method in a class
 that is overridden in one or
 more subclasses. The method does
 different things depending on which
 class was used to instantiate an object.

<pre><code> abstract class Beverage {
 boolean isAcceptableTemperature();
 }

 class Coffee extends Beverage {
 boolean isAcceptableTemperature() { 
 return temperature &gt; 70;
 }
 }

 class Wine extends Beverage {
 boolean isAcceptableTemperature() { 
 return temperature &lt; 10;
 }
 }
</code></pre>

You could also have a method that is
 overloaded with two or more sets of arguments. The method does
 different things based on the
 type(s) of argument(s) passed.

<pre><code> class Server {
 public void pour (Coffee liquid) {
 new Cup().fillToTopWith(liquid);
 }

 public void pour (Wine liquid) {
 new WineGlass().fillHalfwayWith(liquid);
 }

 public void pour (Lemonade liquid, boolean ice) {
 Glass glass = new Glass();
 if (ice) {
 glass.fillToTopWith(new Ice());
 }
 glass.fillToTopWith(liquid);
 }
 }
</code></pre>

blocks|key|362635|text|两者都不是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362636|重载是指使用不同参数的相同函数名。|362637|重写是当子类用自己的方法替换父方法时(这本身并不构成多态性)。|362638|多态性是后期绑定，例如基类(父)方法被调用，但直到运行时应用程序才知道实际的对象是什么-它可能是一个方法不同的子类。这是因为在定义基类的地方可以使用任何子类。|362639|在Java中，您可以在集合库中看到很多多态性：|362640|int+countStuff(List+stuff)+{
++return+stuff.size();
}|code-block|syntax|javascript|362641|list是基类，编译器不知道您是否计算链表、向量、数组或自定义列表实现，只要它的行为类似于List：|362642|List+myStuff+=+new+MyTotallyAwesomeList();
int+result+=+countStuff(myStuff);|362643|如果你超载了，你会得到：|362644|int+countStuff(LinkedList+stuff)+{...}
int+countStuff(ArrayList+stuff)+{...}
int+countStuff(MyTotallyAwesomeList+stuff)+{...}
etc...|362645|编译器将选择与参数匹配的countStuff()的正确版本。|362646|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Neither:

Overloading is when you have the same function name that takes different parameters.

Overriding is when a child class replaces a parent's method with one of its own (this in iteself does not constitute polymorphism).

Polymorphism is late binding, e.g. the base class (parent) methods are being called but not until runtime does the application know what the actual object is - it may be a child class whose methods are different. This is because any child class can be used where a base class is defined.

In Java you see polymorphism a lot with the collections library:

<pre><code>int countStuff(List stuff) {
 return stuff.size();
}
</code></pre>

List is the base class, the compiler has no clue if you're counting a linked list, vector, array, or a custom list implementation, as long as it acts like a List:

<pre><code>List myStuff = new MyTotallyAwesomeList();
int result = countStuff(myStuff);
</code></pre>

If you were overloading you'd have:

<pre><code>int countStuff(LinkedList stuff) {...}
int countStuff(ArrayList stuff) {...}
int countStuff(MyTotallyAwesomeList stuff) {...}
etc...
</code></pre>

and the correct version of countStuff() would be picked by the compiler to match the parameters.

blocks|key|360702|text|多态与一种语言通过使用单个接口统一对待不同对象的能力有关；因此它与重写相关，因此接口(或基类)是多态的，实现者是重写的对象(同一奖章的两个面)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360703|无论如何，这两个术语之间的区别可以用其他语言更好地解释，比如c%2B%2B：如果基本函数是虚拟的，c%2B%2B中的多态对象的行为与java对应的对象一样，但是如果方法不是虚拟的，代码跳转是静态解析的，并且在运行时不检查真实类型，因此，多态性包括对象根据用于访问它的接口的不同行为的能力；让我用伪代码做一个例子：|360704|class+animal+{
++++public+void+makeRumor(){
++++++++print("thump");
++++}
}
class+dog+extends+animal+{
++++public+void+makeRumor(){
++++++++print("woff");
++++}
}

animal+a+=+new+dog();
dog+b+=+new+dog();

a.makeRumor()+->+prints+thump
b.makeRumor()+->+prints+woff|code-block|syntax|javascript|360705|(假设makeRumor不是虚拟的)|360706|java并没有真正提供这种级别的多态性(也称为对象切片)。|360707|动物a=新狗()；狗b=新狗()；|360708|a.makeRumor()+->+prints+thump
b.makeRumor()+->+prints+woff|360709|在这两种情况下，它都将仅打印woff。因为a和b是指狗类|360710|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Polymorphism relates to the ability of a language to have different object treated uniformly by using a single interfaces; as such it is related to overriding, so the interface (or the base class) is polymorphic, the implementor is the object which overrides (two faces of the same medal)

anyway, the difference between the two terms is better explained using other languages, such as c++: a polymorphic object in c++ behaves as the java counterpart if the base function is virtual, but if the method is not virtual the code jump is resolved statically, and the true type not checked at runtime so, polymorphism include the ability for an object to behave differently depending on the interface used to access it; let me make an example in pseudocode:

<pre><code>class animal {
 public void makeRumor(){
 print("thump");
 }
}
class dog extends animal {
 public void makeRumor(){
 print("woff");
 }
}

animal a = new dog();
dog b = new dog();

a.makeRumor() -&gt; prints thump
b.makeRumor() -&gt; prints woff
</code></pre>

(supposing that makeRumor is NOT virtual)

java doesn't truly offer this level of polymorphism (called also object slicing). 

animal a = new dog();
 dog b = new dog();

<pre><code>a.makeRumor() -&gt; prints thump
b.makeRumor() -&gt; prints woff
</code></pre>

on both case it will only print woff..
since a and b is refering to class dog

blocks|key|3365924|text|多态性是类实例的行为能力，就好像它是其继承树中另一个类的实例，通常是它的祖先类之一。例如，在Java中，所有类都继承自Object。因此，您可以创建一个Object类型的变量，并为其分配一个任何类的实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3365925|覆盖是出现在继承自另一个类的类中的一种函数。重写函数“替换”从基类继承的函数，但这样做的方式是，即使其类的实例通过多态性假装为不同的类型，也会调用该函数。参考前面的示例，您可以定义自己的类并覆盖toString()函数。因为此函数是从Object继承的，所以如果您将此类的实例复制到Object类型的变量中，它仍然可用。通常，如果在伪装成对象时在类上调用toString()，那么实际触发的toString版本就是在对象本身上定义的版本。但是，因为该函数是一个重写函数，所以即使当类实例的真实类型隐藏在多态性之后时，也会使用类中的toString()定义。|3365926|重载是定义具有相同名称但具有不同参数的多个方法的操作。它与重写或多态性无关。|3365927|entityMap^0|0|3|0|0|2|0|0|2|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

Polymorphism is the ability of a class instance to behave as if it were an instance of another class in its inheritance tree, most often one of its ancestor classes. For example, in Java all classes inherit from Object. Therefore, you can create a variable of type Object and assign to it an instance of any class.

An override is a type of function which occurs in a class which inherits from another class. An override function "replaces" a function inherited from the base class, but does so in such a way that it is called even when an instance of its class is pretending to be a different type through polymorphism. Referring to the previous example, you could define your own class and override the toString() function. Because this function is inherited from Object, it will still be available if you copy an instance of this class into an Object-type variable. Normally, if you call toString() on your class while it is pretending to be an Object, the version of toString which will actually fire is the one defined on Object itself. However, because the function is an override, the definition of toString() from your class is used even when the class instance's true type is hidden behind polymorphism.

Overloading is the action of defining multiple methods with the same name, but with different parameters. It is unrelated to either overriding or polymorphism.

blocks|key|365442|text|具体地说，说重载或重写并不能给出完整的情况。多态性仅仅是对象根据其类型来专门化其行为的能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|365443|我不同意这里的一些答案，因为重载是多态(参数多态)的一种形式，在相同名称的方法可以在不同的参数类型下表现不同的情况下。操作符重载就是一个很好的例子。您可以定义"%2B“来接受不同类型的参数--比如字符串或整型参数--根据这些类型，"%2B”的行为也会有所不同。|365444|多态性还包括继承和重写方法，尽管它们在基类型中可以是抽象的或虚拟的。就基于继承的多态性而言，Java只支持单类继承，将其多态行为限制为单个基类型链。Java确实支持多个接口的实现，这是另一种形式的多态行为。|365445|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|$]]

Specifically saying overloading or overriding doesn't give the full picture. Polymorphism is simply the ability of an object to specialize its behavior based on its type. 

I would disagree with some of the answers here in that overloading is a form of polymorphism (parametric polymorphism) in the case that a method with the same name can behave differently give different parameter types. A good example is operator overloading. You can define "+" to accept different types of parameters -- say strings or int's -- and based on those types, "+" will behave differently.

Polymorphism also includes inheritance and overriding methods, though they can be abstract or virtual in the base type. In terms of inheritance-based polymorphism, Java only supports single class inheritance limiting it polymorphic behavior to that of a single chain of base types. Java does support implementation of multiple interfaces which is yet another form of polymorphic behavior.

blocks|key|3366012|text|表达多态性的最清晰方法是通过抽象基类(或接口)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3366013|public+abstract+class+Human{
+++...
+++public+abstract+void+goPee();
}|code-block|syntax|javascript|3366014|这个类是抽象的，因为goPee()方法对于人类是不可定义的。它只可定义为男性和女性子类。此外，人类是一个抽象的概念--你不能创造一个既不是男性也不是女性的人类。不是这样就是那样。|offset|length|style|CODE|3366015|因此，我们通过使用抽象类来推迟实现。|3366016|public+class+Male+extends+Human{
...
++++@Override
++++public+void+goPee(){
++++++++System.out.println("Stand+Up");
++++}
}|3366017|和|3366018|public+class+Female+extends+Human{
...
++++@Override
++++public+void+goPee(){
++++++++System.out.println("Sit+Down");
++++}
}|3366019|现在我们可以让一整间屋子的人去小便。|3366020|public+static+void+main(String[]+args){
++++ArrayList<Human>+group+=+new+ArrayList<Human>();
++++group.add(new+Male());
++++group.add(new+Female());
++++//+...+add+more...

++++//+tell+the+class+to+take+a+pee+break
++++for+(Human+person+:+group)+person.goPee();
}|3366021|运行此命令将产生以下结果：|3366022|Stand+Up
Sit+Down
...|3366023|entityMap^0|0|0|A|7|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

The clearest way to express polymorphism is via an abstract base class (or interface)

<pre><code>public abstract class Human{
 ...
 public abstract void goPee();
}
</code></pre>

This class is abstract because the <code>goPee()</code> method is not definable for Humans. It is only definable for the subclasses Male and Female. Also, Human is an abstract concept &mdash; You cannot create a human that is neither Male nor Female. It’s got to be one or the other.

So we defer the implementation by using the abstract class.

<pre><code>public class Male extends Human{
...
 @Override
 public void goPee(){
 System.out.println("Stand Up");
 }
}
</code></pre>

and

<pre><code>public class Female extends Human{
...
 @Override
 public void goPee(){
 System.out.println("Sit Down");
 }
}
</code></pre>

Now we can tell an entire room full of Humans to go pee.

<pre><code>public static void main(String[] args){
 ArrayList&lt;Human&gt; group = new ArrayList&lt;Human&gt;();
 group.add(new Male());
 group.add(new Female());
 // ... add more...

 // tell the class to take a pee break
 for (Human person : group) person.goPee();
}
</code></pre>

Running this would yield:

<pre><code>Stand Up
Sit Down
...
</code></pre>

blocks|key|3153139|text|多态性简单地说就是“多种形式”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3153140|它不需要对achieve...as接口实现进行继承，这根本不是继承，它服务于多态需求。可以说，接口实现比继承“更好”地满足多态需求。|3153141|例如，你会创建一个超类来描述所有能飞的东西吗？我不这么认为。您最好创建一个描述飞行的界面，并将其留在那里。|3153142|因此，由于接口描述行为，而方法名描述行为(对程序员而言)，因此将方法重载视为一种较小形式的多态性并不过分。|3153143|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Polymorphism simply means "Many Forms".

It does not REQUIRE inheritance to achieve...as interface implementation, which is not inheritance at all, serves polymorphic needs. Arguably, interface implementation serves polymorphic needs "Better" than inheritance.

For example, would you create a super-class to describe all things that can fly? I should think not. You would be be best served to create an interface that describes flight and leave it at that.

So, since interfaces describe behavior, and method names describe behavior (to the programmer), it is not too far of a stretch to consider method overloading as a lesser form of polymorphism.

blocks|key|3366100|text|我觉得你们是在混淆概念。多态性是对象在运行时行为不同的能力。要实现这一点，您需要两个必要条件：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3366101|Late+Binding|3366102|Inheritance.|unordered-list-item|3366103|
的|3366104|ordered-list-item|3366105|3366106|已经说过，重载意味着与重写不同的东西，这取决于您使用的语言。例如，在Java中不存在重载而是重载。具有不同基类签名的重载方法在子类中可用。否则它们将被覆盖(请看，我的意思是现在没有办法从对象外部调用基类方法)。|3366107|然而，在C%2B%2B中情况并非如此。任何重载的方法，无论签名是否相同(不同的数量，不同的类型)也会被覆盖。也就是说，当从子类对象外部调用基类的方法时，基类的方法在子类中不再可用。|3366108|所以答案是当谈论Java使用重载的时候。在任何其他语言中都可能与在c%2B%2B中不同|3366109|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|-4|5|J|7|X|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

I think guys your are mixing concepts. Polymorphism is the ability of an object to behave differently at run time. For achieving this, you need two requisites:

<ol>
<li>Late Binding</li>
<li>Inheritance.</li>
</ol>

Having said that overloading means something different to overriding depending on the language you are using. For example in Java does not exist overriding but overloading. Overloaded methods with different signature to its base class are available in the subclass. Otherwise they would be overridden (please, see that I mean now the fact of there is no way to call your base class method from outside the object).

However in C++ that is not so. Any overloaded method, independently whether the signature is the same or not (diffrrent amount, different type) is as well overridden. That is to day, the base class' method is no longer available in the subclass when being called from outside the subclass object, obviously.

So the answer is when talking about Java use overloading. In any other language may be different as it happens in c++

blocks|key|3153369|text|就其含义而言，多态性更有可能……到java中的重写。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3153370|这一切都是关于同一对象在不同情况下的不同行为(以编程的方式...您可以调用不同的参数)|3153371|我认为下面的例子会帮助你理解...虽然它不是纯java代码...|3153372|+++++public+void+See(Friend)
+++++{
++++++++System.out.println("Talk");
+++++}|code-block|syntax|javascript|3153373|但如果我们改变论点..。行为将会改变。|3153374|+++++public+void+See(Enemy)
+++++{
++++++++System.out.println("Run");
+++++}|3153375|人(这里的“对象”)是相同的.|3153376|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Polymorphism is more likely as far as it's meaning is concerned ... to OVERRIDING in java

It's all about different behavior of the SAME object in different situations(In programming way ... you can call different ARGUMENTS) 

I think the example below will help you to understand ... Though it's not PURE java code ...

<pre><code> public void See(Friend)
 {
 System.out.println("Talk");
 }
</code></pre>

But if we change the ARGUMENT ... the BEHAVIOR will be changed ...

<pre><code> public void See(Enemy)
 {
 System.out.println("Run");
 }
</code></pre>

The Person(here the "Object") is same ...

blocks|key|365607|text|多态性是指不止一种形式，相同的对象根据需求执行不同的操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|365608|多态性可以通过使用两种方式来实现，这两种方式是|365609|overriding|365610|Method重载|unordered-list-item|365611|方法|ordered-list-item|365612|365613|365614|方法重载是指使用相同的方法名在同一个类中编写两个或两个以上的方法，但传递的参数不同。|365615|方法覆盖意味着我们在不同的类中使用方法名称，这意味着在子类中使用父类方法。|365616|在Java中，为了实现多态性，超类引用变量可以保存子类对象。|365617|为了实现多态性，每个开发人员都必须在项目中使用相同的方法名称。|365618|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|11|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|15|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|16|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

Polymorphism means more than one form, same object performing different operations according to the requirement.

Polymorphism can be achieved by using two ways, those are

<ol>
<li>Method overriding</li>
<li>Method overloading</li>
</ol>

Method overloading means writing two or more methods in the same class by using same method name, but the passing parameters is different.

Method overriding means we use the method names in the different classes,that means parent class method is used in the child class.

In Java to achieve polymorphism a super class reference variable can hold the sub class object.

To achieve the polymorphism every developer must use the same method names in the project.

blocks|key|3153458|text|重写更像是通过声明一个与上层方法(超级方法)具有相同名称和签名的方法来隐藏继承的方法，这为类添加了多态行为。换句话说，选择调用哪个级别的方法将在运行时做出决定，而不是在编译时。这引出了接口和实现的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3153459|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|$]]

overriding is more like hiding an inherited method by declaring a method with the same name and signature as the upper level method (super method), this adds a polymorphic behaviour to the class .
in other words the decision to choose wich level method to be called will be made at run time not on compile time .
this leads to the concept of interface and implementation .

blocks|key|3153591|text|多态性是一个对象的多个实现，或者你可以说一个对象的多个形式。假设您有Animals类作为抽象基类，它有一个名为movement()的方法，该方法定义动物移动的方式。现在在现实中，我们有不同种类的动物，它们的动作也不同，有些有两条腿，另一些有四条腿，还有一些没有腿，等等。为了定义地球上每种动物的不同movement()，我们需要应用多态性。但是，您需要定义更多的类，如类Dogs、Cats、Fish等。然后，您需要从基类Animals扩展这些类，并使用基于每个动物的新移动功能覆盖其方法movement()。您也可以使用Interfaces来实现这一点。这里的关键字是覆盖，重载是不同的，不被视为多态性。使用重载，您可以定义多个“同名”的方法，但在同一对象或类上使用不同的参数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3153592|entityMap^0|Y|7|1J|A|45|A|55|4|5A|4|5F|4|5U|7|6R|A|78|A|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]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|G|$]]

Polymorphism is a multiple implementations of an object or you could say multiple forms of an object. lets say you have class <code>Animals</code> as the abstract base class and it has a method called <code>movement()</code> which defines the way that the animal moves. Now in reality we have different kinds of animals and they move differently as well some of them with 2 legs, others with 4 and some with no legs, etc.. To define different <code>movement()</code> of each animal on earth, we need to apply polymorphism. However, you need to define more classes i.e. class <code>Dogs</code> <code>Cats</code> <code>Fish</code> etc. Then you need to extend those classes from the base class <code>Animals</code> and override its method <code>movement()</code> with a new movement functionality based on each animal you have. You can also use <code>Interfaces</code> to achieve that. The keyword in here is overriding, overloading is different and is not considered as polymorphism. with overloading you can define multiple methods "with same name" but with different parameters on same object or class.

blocks|key|360996|text|import+java.io.IOException;

class+Super+{

++++protected+Super+getClassName(Super+s)+throws+IOException+{
++++++++System.out.println(this.getClass().getSimpleName()+%2B+"+-+I'm+parent");
++++++++return+null;
++++}

}

class+SubOne+extends+Super+{

++++@Override
++++protected+Super+getClassName(Super+s)++{
++++++++System.out.println(this.getClass().getSimpleName()+%2B+"+-+I'm+Perfect+Overriding");
++++++++return+null;
++++}

}

class+SubTwo+extends+Super+{

++++@Override
++++protected+Super+getClassName(Super+s)+throws+NullPointerException+{
++++++++System.out.println(this.getClass().getSimpleName()+%2B+"+-+I'm+Overriding+and+Throwing+Runtime+Exception");
++++++++return+null;
++++}

}

class+SubThree+extends+Super+{

++++@Override
++++protected+SubThree+getClassName(Super+s)+{
++++++++System.out.println(this.getClass().getSimpleName()%2B+"+-+I'm+Overriding+and+Returning+SubClass+Type");
++++++++return+null;
++++}

}

class+SubFour+extends+Super+{

++++@Override
++++protected+Super+getClassName(Super+s)+throws+IOException+{
++++++++System.out.println(this.getClass().getSimpleName()%2B+"+-+I'm+Overriding+and+Throwing+Narrower+Exception+");
++++++++return+null;
++++}

}

class+SubFive+extends+Super+{

++++@Override
++++public+Super+getClassName(Super+s)+{
++++++++System.out.println(this.getClass().getSimpleName()%2B+"+-+I'm+Overriding+and+have+broader+Access+");
++++++++return+null;
++++}

}

class+SubSix+extends+Super+{

++++public+Super+getClassName(Super+s,+String+ol)+{
++++++++System.out.println(this.getClass().getSimpleName()%2B+"+-+I'm+Perfect+Overloading+");
++++++++return+null;
++++}

}

class+SubSeven+extends+Super+{

++++public+Super+getClassName(SubSeven+s)+{
++++++++System.out.println(this.getClass().getSimpleName()%2B+"+-+I'm+Perfect+Overloading+because+Method+signature+(Argument)+changed.");
++++++++return+null;
++++}

}

public+class+Test{

++++public+static+void+main(String[]+args)+throws+Exception+{

++++++++System.out.println("Overriding\n");

++++++++Super+s1+=+new+SubOne();+s1.getClassName(null);

++++++++Super+s2+=+new+SubTwo();+s2.getClassName(null);

++++++++Super+s3+=+new+SubThree();+s3.getClassName(null);

++++++++Super+s4+=+new+SubFour();+s4.getClassName(null);

++++++++Super+s5+=+new+SubFive();+s5.getClassName(null);

++++++++System.out.println("Overloading\n");

++++++++SubSix+s6+=+new+SubSix();+s6.getClassName(null,+null);

++++++++s6+=+new+SubSix();+s6.getClassName(null);

++++++++SubSeven+s7+=+new+SubSeven();+s7.getClassName(s7);

++++++++s7+=+new+SubSeven();+s7.getClassName(new+Super());

++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|360997|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.io.IOException;

class Super {

 protected Super getClassName(Super s) throws IOException {
 System.out.println(this.getClass().getSimpleName() + " - I'm parent");
 return null;
 }

}

class SubOne extends Super {

 @Override
 protected Super getClassName(Super s) {
 System.out.println(this.getClass().getSimpleName() + " - I'm Perfect Overriding");
 return null;
 }

}

class SubTwo extends Super {

 @Override
 protected Super getClassName(Super s) throws NullPointerException {
 System.out.println(this.getClass().getSimpleName() + " - I'm Overriding and Throwing Runtime Exception");
 return null;
 }

}

class SubThree extends Super {

 @Override
 protected SubThree getClassName(Super s) {
 System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and Returning SubClass Type");
 return null;
 }

}

class SubFour extends Super {

 @Override
 protected Super getClassName(Super s) throws IOException {
 System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and Throwing Narrower Exception ");
 return null;
 }

}

class SubFive extends Super {

 @Override
 public Super getClassName(Super s) {
 System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and have broader Access ");
 return null;
 }

}

class SubSix extends Super {

 public Super getClassName(Super s, String ol) {
 System.out.println(this.getClass().getSimpleName()+ " - I'm Perfect Overloading ");
 return null;
 }

}

class SubSeven extends Super {

 public Super getClassName(SubSeven s) {
 System.out.println(this.getClass().getSimpleName()+ " - I'm Perfect Overloading because Method signature (Argument) changed.");
 return null;
 }

}

public class Test{

 public static void main(String[] args) throws Exception {

 System.out.println("Overriding\n");

 Super s1 = new SubOne(); s1.getClassName(null);

 Super s2 = new SubTwo(); s2.getClassName(null);

 Super s3 = new SubThree(); s3.getClassName(null);

 Super s4 = new SubFour(); s4.getClassName(null);

 Super s5 = new SubFive(); s5.getClassName(null);

 System.out.println("Overloading\n");

 SubSix s6 = new SubSix(); s6.getClassName(null, null);

 s6 = new SubSix(); s6.getClassName(null);

 SubSeven s7 = new SubSeven(); s7.getClassName(s7);

 s7 = new SubSeven(); s7.getClassName(new Super());

 }
}
</code></pre>

blocks|key|365716|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|365717|什么是多态性？|blockquote|365718|365719|365720|来自java+tutorial|offset|length|365721|字典对多态性的定义是指生物学中的一个原理，在这个原理中，一个有机体或物种可以有许多不同的形式或阶段。这一原则也可以应用于面向对象编程和Java语言等语言。类的子类可以定义自己独特的行为，同时还可以共享父类的一些相同功能。|style|BOLD|365722|通过考虑示例和定义，覆盖应该是可接受的答案。|365723|关于你的第二个问题：|365724|365725|如果你有一个抽象基类，它定义了一个没有实现的方法，并且你在子类中定义了这个方法，那么它还会被重写吗？|365726|365727|365728|它应该被称为重写。|365729|看一下这个例子，以了解不同类型的覆盖。|365730|模板方法基类不提供实现，子类必须覆盖完整的方法-+(abstract)|365731|Base类提供默认实现，子类可以通过调用behaviour|unordered-list-item|365732|
|365733|Sub-class将扩展添加到基类实现中，作为第一个statement|365734|365735|Base类定义算法的结构(模板方法)，子类将覆盖算法的一部分|365736|365737|代码片段：|365738|import+java.util.HashMap;

abstract+class+Game+implements+Runnable{

++++protected+boolean+runGame+=+true;
++++protected+Player+player1+=+null;
++++protected+Player+player2+=+null;
++++protected+Player+currentPlayer+=+null;

++++public+Game(){
++++++++player1+=+new+Player("Player+1");
++++++++player2+=+new+Player("Player+2");
++++++++currentPlayer+=+player1;
++++++++initializeGame();
++++}

++++/*+Type+1:+Let+subclass+define+own+implementation.+Base+class+defines+abstract+method+to+force
++++++++sub-classes+to+define+implementation++++
++++*/

++++protected+abstract+void+initializeGame();

++++/*+Type+2:+Sub-class+can+change+the+behaviour.+If+not,+base+class+behaviour+is+applicable+*/
++++protected+void+logTimeBetweenMoves(Player+player){
++++++++System.out.println("Base+class:+Move+Duration:+player.PlayerActTime+-+player.MoveShownTime");
++++}

++++/*+Type+3:+Base+class+provides+implementation.+Sub-class+can+enhance+base+class+implementation+by+calling
++++++++super.methodName()+in+first+line+of+the+child+class+method+and+specific+implementation+later+*/
++++protected+void+logGameStatistics(){
++++++++System.out.println("Base+class:+logGameStatistics:");
++++}
++++/*+Type+4:+Template+method:+Structure+of+base+class+can't+be+changed+but+sub-class+can+some+part+of+behaviour+*/
++++protected+void+runGame()+throws+Exception{
++++++++System.out.println("Base+class:+Defining+the+flow+for+Game:");++
++++++++while+(+runGame)+{
++++++++++++/*
++++++++++++1.+Set+current+player
++++++++++++2.+Get+Player+Move
++++++++++++*/
++++++++++++validatePlayerMove(currentPlayer);++
++++++++++++logTimeBetweenMoves(currentPlayer);
++++++++++++Thread.sleep(500);
++++++++++++setNextPlayer();
++++++++}
++++++++logGameStatistics();
++++}
++++/*+sub-part+of+the+template+method,+which+define+child+class+behaviour+*/
++++protected+abstract+void+validatePlayerMove(Player+p);

++++protected+void+setRunGame(boolean+status){
++++++++this.runGame+=+status;
++++}
++++public+void+setCurrentPlayer(Player+p){
++++++++this.currentPlayer+=+p;
++++}
++++public+void+setNextPlayer(){
++++++++if+(+currentPlayer+==+player1)+{
++++++++++++currentPlayer+=+player2;
++++++++}else{
++++++++++++currentPlayer+=+player1;
++++++++}
++++}
++++public+void+run(){
++++++++try{
++++++++++++runGame();
++++++++}catch(Exception+err){
++++++++++++err.printStackTrace();
++++++++}
++++}
}

class+Player{
++++String+name;
++++Player(String+name){
++++++++this.name+=+name;
++++}
++++public+String+getName(){
++++++++return+name;
++++}
}

/*+Concrete+Game+implementation++*/
class+Chess+extends+Game{
++++public+Chess(){
++++++++super();
++++}
++++public+void+initializeGame(){
++++++++System.out.println("Child+class:+Initialized+Chess+game");
++++}
++++protected+void+validatePlayerMove(Player+p){
++++++++System.out.println("Child+class:+Validate+Chess+move:"%2Bp.getName());
++++}
++++protected+void+logGameStatistics(){
++++++++super.logGameStatistics();
++++++++System.out.println("Child+class:+Add+Chess+specific+logGameStatistics:");
++++}
}
class+TicTacToe+extends+Game{
++++public+TicTacToe(){
++++++++super();
++++}
++++public+void+initializeGame(){
++++++++System.out.println("Child+class:+Initialized+TicTacToe+game");
++++}
++++protected+void+validatePlayerMove(Player+p){
++++++++System.out.println("Child+class:+Validate+TicTacToe+move:"%2Bp.getName());
++++}
}

public+class+Polymorphism{
++++public+static+void+main(String+args[]){
++++++++try{

++++++++++++Game+game+=+new+Chess();
++++++++++++Thread+t1+=+new+Thread(game);
++++++++++++t1.start();
++++++++++++Thread.sleep(1000);
++++++++++++game.setRunGame(false);
++++++++++++Thread.sleep(1000);

++++++++++++game+=+new+TicTacToe();
++++++++++++Thread+t2+=+new+Thread(game);
++++++++++++t2.start();
++++++++++++Thread.sleep(1000);
++++++++++++game.setRunGame(false);

++++++++}catch(Exception+err){
++++++++++++err.printStackTrace();
++++++++}+++++++
++++}
}|code-block|syntax|javascript|365739|输出：|365740|Child+class:+Initialized+Chess+game
Base+class:+Defining+the+flow+for+Game:
Child+class:+Validate+Chess+move:Player+1
Base+class:+Move+Duration:+player.PlayerActTime+-+player.MoveShownTime
Child+class:+Validate+Chess+move:Player+2
Base+class:+Move+Duration:+player.PlayerActTime+-+player.MoveShownTime
Base+class:+logGameStatistics:
Child+class:+Add+Chess+specific+logGameStatistics:
Child+class:+Initialized+TicTacToe+game
Base+class:+Defining+the+flow+for+Game:
Child+class:+Validate+TicTacToe+move:Player+1
Base+class:+Move+Duration:+player.PlayerActTime+-+player.MoveShownTime
Child+class:+Validate+TicTacToe+move:Player+2
Base+class:+Move+Duration:+player.PlayerActTime+-+player.MoveShownTime
Base+class:+logGameStatistics:|365741|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html^0|0|0|0|0|7|8|0|0|27|V|0|A|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|1W|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1X|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1Y|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1Z|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|20|7|@]|8|@$H|21|I|22|1|23]]|9|$]]|$1|J|3|K|4|5|6|24|7|@$H|25|I|26|L|M]]|8|@]|9|$]]|$1|N|3|O|4|5|6|27|7|@$H|28|I|29|L|M]]|8|@]|9|$]]|$1|P|3|Q|4|5|6|2A|7|@]|8|@]|9|$]]|$1|R|3|-4|4|5|6|2B|7|@]|8|@]|9|$]]|$1|S|3|T|4|C|6|2C|7|@]|8|@]|9|$]]|$1|U|3|-4|4|5|6|2D|7|@]|8|@]|9|$]]|$1|V|3|-4|4|5|6|2E|7|@]|8|@]|9|$]]|$1|W|3|X|4|5|6|2F|7|@]|8|@]|9|$]]|$1|Y|3|Z|4|5|6|2G|7|@]|8|@]|9|$]]|$1|10|3|11|4|5|6|2H|7|@]|8|@]|9|$]]|$1|12|3|13|4|14|6|2I|7|@]|8|@]|9|$]]|$1|15|3|16|4|5|6|2J|7|@]|8|@]|9|$]]|$1|17|3|18|4|14|6|2K|7|@]|8|@]|9|$]]|$1|19|3|16|4|5|6|2L|7|@]|8|@]|9|$]]|$1|1A|3|1B|4|14|6|2M|7|@]|8|@]|9|$]]|$1|1C|3|-4|4|5|6|2N|7|@]|8|@]|9|$]]|$1|1D|3|1E|4|5|6|2O|7|@]|8|@]|9|$]]|$1|1F|3|1G|4|1H|6|2P|7|@]|8|@]|9|$1I|1J]]|$1|1K|3|1L|4|5|6|2Q|7|@]|8|@]|9|$]]|$1|1M|3|1N|4|1H|6|2R|7|@]|8|@]|9|$1I|1J]]|$1|1O|3|-4|4|5|6|2S|7|@]|8|@]|9|$]]]|1P|$1Q|$4|1R|1S|1T|9|$1U|1V]]]]

<blockquote>
 what is polymorphism?
</blockquote>

From java <a href="https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html" rel="nofollow">tutorial</a>

The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.

By considering the examples and definition, overriding should be accepted answer. 

Regarding your second query:

<blockquote>
 IF you had a abstract base class that defined a method with no implementation, and you defined that method in the sub class, is that still overridding?
</blockquote>

It should be called overriding. 

Have a look at this example to understand different types of overriding. 

<ol>
<li>Base class provides no implementation and sub-class has to override complete method - (abstract)</li>
<li>Base class provides default implementation and sub-class can change the behaviour</li>
<li>Sub-class adds extension to base class implementation by calling <code>super.methodName()</code> as first statement</li>
<li>Base class defines structure of the algorithm (Template method) and sub-class will override a part of algorithm</li>
</ol>

code snippet:

<pre><code>import java.util.HashMap;

abstract class Game implements Runnable{

 protected boolean runGame = true;
 protected Player player1 = null;
 protected Player player2 = null;
 protected Player currentPlayer = null;

 public Game(){
 player1 = new Player("Player 1");
 player2 = new Player("Player 2");
 currentPlayer = player1;
 initializeGame();
 }

 /* Type 1: Let subclass define own implementation. Base class defines abstract method to force
 sub-classes to define implementation 
 */

 protected abstract void initializeGame();

 /* Type 2: Sub-class can change the behaviour. If not, base class behaviour is applicable */
 protected void logTimeBetweenMoves(Player player){
 System.out.println("Base class: Move Duration: player.PlayerActTime - player.MoveShownTime");
 }

 /* Type 3: Base class provides implementation. Sub-class can enhance base class implementation by calling
 super.methodName() in first line of the child class method and specific implementation later */
 protected void logGameStatistics(){
 System.out.println("Base class: logGameStatistics:");
 }
 /* Type 4: Template method: Structure of base class can't be changed but sub-class can some part of behaviour */
 protected void runGame() throws Exception{
 System.out.println("Base class: Defining the flow for Game:"); 
 while ( runGame) {
 /*
 1. Set current player
 2. Get Player Move
 */
 validatePlayerMove(currentPlayer); 
 logTimeBetweenMoves(currentPlayer);
 Thread.sleep(500);
 setNextPlayer();
 }
 logGameStatistics();
 }
 /* sub-part of the template method, which define child class behaviour */
 protected abstract void validatePlayerMove(Player p);

 protected void setRunGame(boolean status){
 this.runGame = status;
 }
 public void setCurrentPlayer(Player p){
 this.currentPlayer = p;
 }
 public void setNextPlayer(){
 if ( currentPlayer == player1) {
 currentPlayer = player2;
 }else{
 currentPlayer = player1;
 }
 }
 public void run(){
 try{
 runGame();
 }catch(Exception err){
 err.printStackTrace();
 }
 }
}

class Player{
 String name;
 Player(String name){
 this.name = name;
 }
 public String getName(){
 return name;
 }
}

/* Concrete Game implementation */
class Chess extends Game{
 public Chess(){
 super();
 }
 public void initializeGame(){
 System.out.println("Child class: Initialized Chess game");
 }
 protected void validatePlayerMove(Player p){
 System.out.println("Child class: Validate Chess move:"+p.getName());
 }
 protected void logGameStatistics(){
 super.logGameStatistics();
 System.out.println("Child class: Add Chess specific logGameStatistics:");
 }
}
class TicTacToe extends Game{
 public TicTacToe(){
 super();
 }
 public void initializeGame(){
 System.out.println("Child class: Initialized TicTacToe game");
 }
 protected void validatePlayerMove(Player p){
 System.out.println("Child class: Validate TicTacToe move:"+p.getName());
 }
}

public class Polymorphism{
 public static void main(String args[]){
 try{

 Game game = new Chess();
 Thread t1 = new Thread(game);
 t1.start();
 Thread.sleep(1000);
 game.setRunGame(false);
 Thread.sleep(1000);

 game = new TicTacToe();
 Thread t2 = new Thread(game);
 t2.start();
 Thread.sleep(1000);
 game.setRunGame(false);

 }catch(Exception err){
 err.printStackTrace();
 } 
 }
}
</code></pre>

output:

<pre><code>Child class: Initialized Chess game
Base class: Defining the flow for Game:
Child class: Validate Chess move:Player 1
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Child class: Validate Chess move:Player 2
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Base class: logGameStatistics:
Child class: Add Chess specific logGameStatistics:
Child class: Initialized TicTacToe game
Base class: Defining the flow for Game:
Child class: Validate TicTacToe move:Player 1
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Child class: Validate TicTacToe move:Player 2
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Base class: logGameStatistics:
</code></pre>

In terms of Java, when someone asks: 

<blockquote>
 what is polymorphism?
</blockquote>

Would overloading or overriding be an acceptable answer?

I think there is a bit more to it than that. 

IF you had a abstract base class that defined a method with no implementation, and you defined that method in the sub class, is that still overridding?

I think overloading is not the right answer for sure.

Polymorphism vs Overriding vs Overloading

软件工程

编译器

Java

在Java方面，当有人问：什么是多态性？重载或重载是可接受的答案吗？我认为还有更多的原因。如果你有一个抽象基类，它定义了一个没有实现的方法，而你在子类中定义了这个方法，那么它还会被重写吗？我认为重载肯定不是正确的答案。

问多态vs覆盖vs重载
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问多态vs覆盖vs重载EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问多态vs覆盖vs重载
EN