什么是多态，什么是它，它是如何使用的？

我正在观看Google Tech Talksvideo，他们经常提到多态性。

什么是多态，什么是它，它是如何使用的？

Answer 1

如果你考虑这个术语的希腊词根，它应该变得明显。

• 多=多：多边形=多面，聚苯乙烯=许多苯乙烯^（a） ，多边形=多种语言，等等。
• Morph =变化或forms：形态=生物形态的研究，Morpheus =梦想中的希腊之神能够采取任何forms。

所以多态性是在编程中为不同的底层表单（数据types）呈现相同的接口的能力。

例如，在许多语言中，整数和浮点数是隐式多态的，因为可以进行加，减，乘等操作，而不pipetypes是否不同。 他们很less被视为通常的对象。

但是，以同样的方式，像BigDecimal或Rational或Imaginary这样的类也可以提供这些操作，即使它们使用不同的数据types。

经典的例子是Shape类和所有可以inheritance的类（正方形，圆形，十二面体，不规则多边形，图示等）。

使用多态性，这些类中的每一个都将具有不同的基础数据。 点形状只需要两个坐标（当然假设它在二维空间中）。 一个圆圈需要一个中心和半径。 正方形或矩形需要两个坐标左上angular和右下angular以及（可能）旋转。 一个不规则的多边形需要一系列的线条。

通过让这个类负责它的代码以及它的数据，你可以实现多态。 在这个例子中，每个类都有它自己的Draw()函数，客户端代码可以简单地做到：

 shape.Draw() 

为任何形状获得正确的行为。

这与代码与数据分离的做法形成了对比，您将拥有诸如drawSquare()和drawCircle()函数。

面向对象，多态和inheritance都是紧密相关的概念，它们对知道至关重要。 在我漫长的职业生涯中，有很多“银弹”，基本上只是失败了，但是OO范式已经变成了一个很好的例子。 学习它，理解它，喜欢它 – 你会很高兴你做到了:-)

---

^（a）我原本写这个笑话，结果certificate是正确的，所以并不那么有趣。 单体苯乙烯碰巧由碳和氢制成， C 8 H 8 ，而聚苯乙烯则由(C 8 H 8 ) n 。

也许我应该说，虽然现在我不得不解释一下这个笑话，但是这个字母p出现却是很多的，即使这样也不好笑。

有时候，你应该放弃，而你后面:-)

Answer 2

多态性是指可以将某个对象视为某种types的通用版本，但是当您访问该对象时，代码将确定该types的确切types，并调用相关的代码。

这里是C＃中的一个例子。 在控制台应用程序中创build四个类：

 public abstract class Vehicle { public abstract int Wheels; } public class Bicycle : Vehicle { public override int Wheels() { return 2; } } public class Car : Vehicle { public override int Wheels() { return 4; } } public class Truck : Vehicle { public override int Wheels() { return 18; } } 

现在在控制台应用程序的模块的Main（）中创build以下内容：

 public void Main() { List<Vehicle> vehicles = new List<Vehicle>(); vehicles.Add(new Bicycle()); vehicles.Add(new Car()); vehicles.Add(new Truck()); foreach (Vehicle v in vehicles) { Console.WriteLine( string.Format("A {0} has {1} wheels.", v.GetType().Name, v.Wheels)); } } 

在这个例子中，我们创build一个基类Vehicle的列表，它不知道每个子类有多less个车轮，但是知道每个子类负责知道它有多less个车轮。

然后，我们添加一辆自行车，汽车和卡车的名单。

接下来，我们可以遍历列表中的每个车辆，并将它们全部等同处理，但是当我们访问每个车辆车轮的属性时，Vehicle类将该代码的执行委托给相关的子类。

这段代码被认为是多态的，因为执行的确切代码是由在运行时被引用的子类决定的。

我希望这可以帮助你。

Answer 3

从理解和应用PHP中的多态性 ，感谢史蒂夫指导。

对于一个非常简单的概念来说，多态是个很长的词汇。

多态性描述了面向对象编程中的一种模式，其中类在共享通用接口时具有不同的function。

多态的美妙之处在于，使用不同类的代码不需要知道它正在使用哪个类，因为它们都以相同的方式使用。 一个真实世界的多态性比喻是一个button。 每个人都知道如何使用button：你只需要施加压力。 然而，button“做什么”取决于它所连接的内容以及使用它的上下文，但是结果并不影响它的使用方式。 如果你的老板告诉你按下一个button，你已经拥有完成任务所需的所有信息。

在编程世界中，多态性被用来使应用程序更加模块化和可扩展。 您可以根据自己的需要创build可互换的对象，而不是使用混乱的条件语句来描述不同的操作过程。 这是多态的基本目标。

Answer 4

如果有人对这些人说CUT

1. 外科医生
2. 发型师
3. 演员

会发生什么？

• 外科医生将开始做一个切口。
• 发型师会开始剪头发。
• 演员会突然停止演出现场，等待导演指导。

所以上面的表示显示了OOP中的多态性（同名，不同行为）。

如果你要进行面试，面试官要求你告诉/展示我们坐在同一个房间里的多态性的一个实例，

答案 – 门/窗户

想知道如何？

通过门窗 – 一个人可以来，空气可以来，光可以来，雨可以来。

为了更好地理解它并以一种简单的方式使用上面的例子。如果需要参考代码，请按照上述的答案。

Answer 5

多态性：

它是面向对象编程的概念。不同的对象以各自的方式对相同的消息进行响应的能力称为多态。

多态性是由于每个类都存在于自己的命名空间中。 在类定义中分配的名称不会与在其外部分配的名称冲突。 对象的数据结构中的实例variables和对象的方法都是如此：

• 就像C结构的字段在受保护的命名空间中一样，对象的实例variables也是如此。

• 方法名称也受保护。 与C函数的名称不同，方法名称不是全局符号。 一个类中的方法名称不能与其他类中的方法名称冲突; 两个非常不同的类可以实现相同名称的方法。

方法名称是对象接口的一部分。 当发送消息请求对象执行某些操作时，消息会命名该对象应该执行的方法。 因为不同的对象可以有同名的方法，消息的含义必须相对于接收消息的特定对象来理解。 发送给两个不同对象的相同消息可以调用两个不同的方法。

多态的主要好处是简化了编程接口。 它允许build立可以在课堂上重复使用的约定。 不是为每个添加到程序的新function创build一个新名称，而是可以重复使用相同的名称。 编程接口可以被描述为一组抽象行为，与实现它们的类不同。

例子：

示例1：这是用Python 2.x编写的一个简单示例。

 class Animal: def __init__(self, name): # Constructor of the class self.name = name def talk(self): # Abstract method, defined by convention only raise NotImplementedError("Subclass must implement abstract method") class Cat(Animal): def talk(self): return 'Meow!' class Dog(Animal): def talk(self): return 'Woof! Woof!' animals = [Cat('Missy'), Dog('Lassie')] for animal in animals: print animal.name + ': ' + animal.talk() 

示例2：使用方法重载和方法重载概念在Java中实现多态。

让我们考虑一下讨论多态的汽车示例。 以任何品牌如福特，本田，丰田，宝马，奔驰等，一切都是types的车。

但每个人都有自己的先进特征和更先进的技术参与他们的行动行为。

现在让我们来创build一个基本types的车

Car.java

 public class Car { int price; String name; String color; public void move(){ System.out.println("Basic Car move"); } } 

让我们来实施福特汽车的例子。

福特将typesCar扩展为inheritance其所有成员（属性和方法）。

Ford.java

 public class Ford extends Car{ public void move(){ System.out.println("Moving with V engine"); } } 

上面的福特类扩展了Car类，并实现了move（）方法。 尽pipe福特已经通过inheritance方式提供了移动方法，但福特仍然以自己的方式实施了该方法。 这被称为方法覆盖。

Honda.java

 public class Honda extends Car{ public void move(){ System.out.println("Move with i-VTEC engine"); } } 

就像福特一样，本田也扩大了汽车types，并以自己的方式实施了移动方法。

方法重写是启用多态性的重要特征。 使用方法重写，Subtypes可以改变通过inheritance可用的方法的工作方式。

PolymorphismExample.java

 public class PolymorphismExample { public static void main(String[] args) { Car car = new Car(); Car f = new Ford(); Car h = new Honda(); car.move(); f.move(); h.move(); } } 

多态性示例输出：

在PolymorphismExample类main方法中，我创build了三个对象 – Car，Ford和Honda。 所有三个对象都由Cartypes引用。

请注意这里重要的一点，一个超级types可以引用一个Subtypes的对象，但副词是不可能的。 原因是超级类的所有成员都可以使用inheritance来使用子类，在编译期间，编译器会尝试评估我们正在使用的引用types是否有他正试图访问的方法。

因此，对于PolymorphismExample中的参考car，f和h，移动方法存在于Cartypes中。 所以，编译器通过编译过程没有任何问题。

但是当涉及到运行时执行时，虚拟机将调用子types对象上的方法。 所以，move（）方法从它们各自的实现中调用。

所以，所有的对象都是Cartypes的，但是在运行时，执行依赖于调用发生的对象。 这被称为多态性。

Answer 6

多态性是把对象类视为父类的能力。

例如，假设有一个叫做Animal的类，还有一个叫Animal的类inheritance了Animal。 多态性是将任何Dog对象作为动物对象处理的能力，如下所示：

 Dog* dog = new Dog; Animal* animal = dog; 

Answer 7

我希望为你解释一般的概念，一旦你明白了，那么你将能够理解上面的一些答案：

类比解释

美国总统采用多态。 怎么样？ 那么他有很多顾问：

1. 军事顾问
2. 法律顾问
3. 核物理学家（作为顾问）
4. 医疗顾问
5. 等等

每个人都应该只负责一件事：例如：

总统不是镀锌或量子物理的专家。 他不知道很多事情，但是他只知道一件事情：如何pipe理这个国家。

这与代码是一样的：关心和责任应该分开给相关的class级/人员。 否则，总统就会知道这个世界上的一切 – 整个维基百科。 想象一下，在你的代码中有整个维基百科：这将是一个噩梦来维护。

为什么总统知道这些具体事情是一个坏主意？

如果总统明确告诉人们该做什么，那就意味着总统需要知道该怎么做。 如果总统自己需要了解具体的事情，那就意味着当你需要改变的时候，你需要把它做成两个地方，而不是一个。

例如，如果EPA改变了污染法则，那么当发生这种情况时，您必须对EPA级别和总统级别进行更改。 在两个地方而不是一个地方更改代码可能很危险 – 因为维护起来要困难得多。

有更好的方法吗？

有一个更好的方法：总统不需要知道任何事情的具体情况 – 他可以向专门负责这些事情的人提出最好的build议。

他可以使用多态的方法来pipe理国家。

例子 – 你应该在你的代码中做什么

总统所做的就是要求人们给他build议 – 而这正是他在现实生活中所做的 – 而这正是一个好的总统应该做的。 他的顾问们都有不同的反应，但他们都知道总统的意思是：Advise（）。 他有数百人涌入他的办公室。 这实际上并不重要，他们是谁。 总统知道的是，当他要求他们“劝告”时，他们知道如何做出相应的回应 ：

例如：

 public class MisterPresident { public void RunTheCountry() { // assume the Petraeus and Condi classes etc are instantiated. Petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah Condolezza.Advise(); // # she says negotiate trade deal with Iran HealthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare } } 

这种方法允许总统在不知道任何有关军事，卫生保健或国际外交的情况下，从字面上运行国家：细节留给专家。 总统唯一需要知道的是：“build议（）”。

你不想要的东西：

 public void RunTheCountry() // people walk into the Presidents office and he tells them what to do // depending on who they are. // Fallujah Advice - Mr Prez tells his military exactly what to do. - Petraeus.IncreaseTroopNumbers() - Petraeus.ImproveSecurity() - Petraeus.PayContractors() // Condi diplomacy advice - Prez tells Condi how to negotiate - Condi.StallNegotiations() - Condi.LowBallFigure() // Health care - HealthOfficials.IncreasePremiums() - HealthOfficials.AddPreexistingConditions() 

没有！ 没有！ 没有！ 在上述情况下，总统正在做所有的工作：他知道增加部队人数和预先存在的条件。 这意味着，如果中东政策发生变化，那么总统将不得不改变他的命令， 以及彼得雷乌斯阶级。 我们只需要改变彼得雷乌斯class，因为总统不应该陷入这样的细节之中。 他不需要知道细节。 他所需要知道的是，如果他下了一个订单，一切都将被照顾。 所有的细节都应该由专家来决定。

这可以让总统做他最擅长的事情：制定一般政策，好看，打高尔夫：P。

它是如何实现的 – 通过基类或通用接口

简而言之，这就是多态。 究竟是如何完成的？ 通过“实现一个通用接口”或通过使用inheritance – 见上面的答案，这更详细的说明。 换句话说，Petraeus，Condi和HealthOfficials都是实现一个接口的类 – 我们称之为IAdvisor接口， IAdvisor包含一个方法： Advise() 。 但是现在我们正在深入细节。

概要

所有你真正需要知道的是这样的：

• 总统不需要知道具体情况 – 那些留给别人。
• 所有的总统需要知道的是要问，谁走在门外，为他提供build议 – 我们知道他们绝对会知道该怎么做，当被要求提供build议（因为他们都是实际上，顾问（或IAdvisors :)）

我真的希望它可以帮助你。 如果你不明白发表评论，我会再试一次。

Answer 8

通常这是指typesA的对象的行为类似于typesB的对象的能力。在面向对象的编程中，通常通过inheritance来实现。 一些维基百科链接阅读更多：

• 面向对象程序devise中的多态性
• types多态性

编辑：修复了断开的链接。

Answer 9

多态性是这样的：

 class Cup { int capacity } class TeaCup : Cup { string flavour } class CoffeeCup : Cup { string brand } Cup c = new CoffeeCup(); public int measure(Cup c) { return c.capacity } 

你可以传递一个杯子而不是特定的实例。 这有助于通用性，因为您不必为每种杯子types提供特定的measure（）实例

Answer 10

我知道这是一个老问题，有很多很好的答案，但我想包括一个句子的答案：

将派生types视为基types。

上面有很多例子表明了这一点，但我觉得这是一个很好的简洁的答案。

Answer 11

（我正在浏览另一篇完全不同的文章..并且多态性突然出现…现在我想我知道什么是多态性…但显然不是以这种美丽的方式解释..想写在某个地方..更好的还是会分享的…）

http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

从这个部分读：

多态性 这是一个怪异的方式，说不同的名词可以有相同的动词适用于他们。

Answer 12

术语多态性来自：

poly =很多

态度=改变的能力

在编程中，多态是一种“技术”，让你“看”一个对象不止一种types的东西。 例如：

一个学生对象也是一个人对象。 如果你对学生“看”（即投），你可能会要求学生证。 你不能总是跟一个人做对吧？ （一个人不一定是学生，因此可能没有学生证）。 但是，一个人可能有一个名字。 一个学生也是。

底线，从不同的“angular度”看“同一个对象”可以给你不同的“视angular”（即不同的属性或方法）

所以这种技术可以让你build立可以从不同angular度“看”的东西。

为什么我们使用多态？ 对于初学者…抽象。 在这一点上应该是足够的信息:)

Answer 13

让我们用一个比喻。 对于一个给定的音乐剧本，每个演奏这个剧本的音乐家都会给出自己的解释。

音乐家可以抽象为界面，音乐家所属的types可以是一个抽象类，它定义了一些全球性的解释规则，每个演奏的音乐家都可以用一个具体的类来build模。

如果您是音乐作品的聆听者，那么您可以参考巴赫的“Fuga and Tocata”这个剧本，每个执行这个剧本的音乐家都会以自己的方式进行多forms的演绎。

这只是一个可能的devise（在Java中）的例子：

 public interface Musician { public void play(Work work); } public interface Work { public String getScript(); } public class FugaAndToccata implements Work { public String getScript() { return Bach.getFugaAndToccataScript(); } } public class AnnHalloway implements Musician { public void play(Work work) { // plays in her own style, strict, disciplined String script = work.getScript() } } public class VictorBorga implements Musician { public void play(Work work) { // goofing while playing with superb style String script = work.getScript() } } public class Listener { public void main(String[] args) { Musician musician; if (args!=null && args.length > 0 && args[0].equals("C")) { musician = new AnnHalloway(); } else { musician = new TerryGilliam(); } musician.play(new FugaAndToccata()); } 

Answer 14

多态性是程序员根据这些对象的需要，为不同types的对象编写相同名称的方法的能力。 例如，如果您正在开发一个名为Fraction的类和一个名为ComplexNumber的类，则这两个类都可能包含一个名为display()的方法，但是每个方法都会以不同的方式实现该方法。 例如，在PHP中，你可以像这样实现它：

 // Class definitions class Fraction { public $numerator; public $denominator; public function __construct($n, $d) { // In real life, you'd do some type checking, making sure $d != 0, etc. $this->numerator = $n; $this->denominator = $d; } public function display() { echo $this->numerator . '/' . $this->denominator; } } class ComplexNumber { public $real; public $imaginary; public function __construct($a, $b) { $this->real = $a; $this->imaginary = $b; } public function display() { echo $this->real . '+' . $this->imaginary . 'i'; } } // Main program $fraction = new Fraction(1, 2); $complex = new ComplexNumber(1, 2); echo 'This is a fraction: ' $fraction->display(); echo "\n"; echo 'This is a complex number: ' $complex->display(); echo "\n"; 

输出：

 This is a fraction: 1/2 This is a complex number: 1 + 2i 

其他一些答案似乎意味着多态只能与inheritance结合使用; 例如，可能Fraction和ComplexNumber都实现了一个叫做Number的抽象类，它有一个display()方法，然后Fraction和ComplexNumber都有义务实现。 但是你不需要inheritance来利用多态。

至less在像PHP这样的dynamictypes语言（我不知道C ++或Java）中，多态性允许开发人员提前调用一个方法，而不必知道对象的types，并且相信方法的正确实现将会叫做。 例如，假设用户select创build的Number的types：

 $userNumberChoice = $_GET['userNumberChoice']; switch ($userNumberChoice) { case 'fraction': $userNumber = new Fraction(1, 2); break; case 'complex': $userNumber = new ComplexNumber(1, 2); break; } echo "The user's number is: "; $userNumber->display(); echo "\n"; 

在这种情况下，即使开发人员不能提前知道用户是select分数还是复数，也会调用相应的display()方法。

Answer 15

我为另一个问题提供了一个关于多态性的高级概述：

在c ++中的多态性

希望它有帮助。 提取物…

…它有助于从一个简单的testing开始，并定义[多态性]。 考虑下面的代码：

 Type1 x; Type2 y; f(x); f(y); 

在这里， f()是执行一些操作，并被赋予值x和y作为input。 为了多态， f()必须能够使用至less两个不同types的值（例如int和double ）来查找和执行types适当的代码。

（ 在c ++中继续多态 ）

Answer 16

多态性的字面意思是，多个形状。 （或许多forms）：来自不同类别和同名方法的对象，但工作stream程是不同的。 一个简单的例子是：

考虑一个人X.

他只是一个人，但是他也是一样的。 你可能会问：

他是他母亲的儿子。 朋友给他的朋友。 他的妹妹的兄弟。

Answer 17

OOP中的多态意味着类可以有不同的types，inheritance是实现多态的一种方式。

例如Shape是一个界面，它有Square ， Circle ， Diamond子types。 now you have a Square object, you can upcasting Square to Shape automatically, because Square is a Shape. But when you try to downcasting Shape to Square, you must do explicit type casting, because you can't say Shape is Square, it could be Circle as well. so you need manually cast it with code like Square s = (Square)shape , what if the shape is Circle, you will get java.lang.ClassCastException , because Circle is not Square.

Answer 18

Generally speaking, it's the ability to interface a number of different types of object using the same or a superficially similar API. There are various forms:

• Function overloading: defining multiple functions with the same name and different parameter types, such as sqrt(float), sqrt(double) and sqrt(complex). In most languages that allow this, the compiler will automatically select the correct one for the type of argument being passed into it, thus this is compile-time polymorphism.

• Virtual methods in OOP: a method of a class can have various implementations tailored to the specifics of its subclasses; each of these is said to override the implementation given in the base class. Given an object that may be of the base class or any of its subclasses, the correct implementation is selected on the fly, thus this is run-time polymorphism.

• Templates: a feature of some OO languages whereby a function, class, etc. can be parameterised by a type. For example, you can define a generic "list" template class, and then instantiate it as "list of integers", "list of strings", maybe even "list of lists of strings" or the like. Generally, you write the code once for a data structure of arbitrary element type, and the compiler generates versions of it for the various element types.

Answer 19

Polymorphism is an ability of object which can be taken in many forms. For example in human class a man can act in many forms when we talk about relationships. EX: A man is a father to his son and he is husband to his wife and he is teacher to his students.

Answer 20

Polymorphism => Different execution according to instance of class, not type of reference variable.

A interface type reference variable can refer any of the class instance that implements that interface.

Answer 21

Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object. In this example that is written in Java, we have three type of vehicle. We create three different object and try to run their wheels method:

 public class PolymorphismExample { public static abstract class Vehicle { public int wheels(){ return 0; } } public static class Bike extends Vehicle { @Override public int wheels() { return 2; } } public static class Car extends Vehicle { @Override public int wheels() { return 4; } } public static class Truck extends Vehicle { @Override public int wheels() { return 18; } } public static void main(String[] args) { Vehicle bike = new Bike(); Vehicle car = new Car(); Vehicle truck = new Truck(); System.out.println("Bike has "+bike.wheels()+" wheels"); System.out.println("Car has "+car.wheels()+" wheels"); System.out.println("Truck has "+truck.wheels()+" wheels"); } } 

结果是：

For more information please visit https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . 我希望它有帮助。

Answer 22

Polymorphism allows the same routine (function, method) to act on different types.

Since many existing answers are conflating subtyping with polymorphism, here are three ways (including subtyping) to implement polymorphism.

• Parameteric (generic) polymorphism allows a routine to accept one or more type parameters, in addition to normal parameters, and runs itself on those types.
• Subtype polymorphism allows a routine to act on any subtype of its parameters.
• Ad hoc polymorphism generally uses routine overloading to grant polymorphic behavior, but can refer to other polymorphism implementations too.

也可以看看：

http://wiki.c2.com/?CategoryPolymorphism

https://en.wikipedia.org/wiki/Polymorphism_(computer_science)

Answer 23

In Object Oriented languages, polymorphism allows treatment and handling of different data types through the same interface. For example, consider inheritance in C++: Class B is derived from Class A. A pointer of type A* (pointer to class A) may be used to handle both an object of class A AND an object of class B.

Answer 24

Polymorphism in coding terms is when your object can exist as multiple types through inheritance etc. If you create a class named "Shape" which defines the number of sides your object has then you can then create a new class which inherits it such as "Square". When you subsequently make an instance of "Square" you can then cast it back and forward from "Shape" to "Square" as required.

Answer 25

In object-oriented programming, polymorphism refers to a programming language's ability to process objects differently depending on their data type or class . More specifically, it is the ability to redefine methods for derived classes.

Answer 26

Polymorphism is the ability to use an object in a given class, where all components that make up the object are inherited by subclasses of the given class. This means that once this object is declared by a class, all subclasses below it (and thier subclasses, and so on until you reach the farthest/lowest subclass) inherit the object and it's components (makeup).

Do remember that each class must be saved in separate files.

The following code exemplifies Polymorphism:

The SuperClass:

 public class Parent { //Define things that all classes share String maidenName; String familyTree; //Give the top class a default method public void speak(){ System.out.println("We are all Parents"); } } 

The father, a subclass:

 public class Father extends Parent{ //Can use maidenName and familyTree here String name="Joe"; String called="dad"; //Give the top class a default method public void speak(){ System.out.println("I am "+name+", the father."); } } 

The child, another subclass:

 public class Child extends Father { //Can use maidenName, familyTree, called and name here //Give the top class a default method public void speak(){ System.out.println("Hi "+called+". What are we going to do today?"); } } 

The execution method, references Parent class to start:

 public class Parenting{ public static void main(String[] args) { Parent parents = new Parent(); Parent parent = new Father(); Parent child = new Child(); parents.speak(); parent.speak(); child.speak(); } } 

Note that each class needs to be declared in separate *.java files. The code should compile. Also notice that you can continually use maidenName and familyTree farther down. That is the concept of polymorphism. The concept of inheritance is also explored here, where one class is can be used or is further defined by a subclass.

Hope this helps and makes it clear. I will post the results when I find a computer that I can use to verify the code. Thanks for the patience!

Answer 27

Polymorphism gives you the ability to create one module calling another, and yet have the compile time dependency point against the flow of control instead of with the flow of control.

By using polymorphism, a high level module does not depend on low-level module. Both depend on abstractions. This helps us to apply the dependency inversion principle( https://en.wikipedia.org/wiki/Dependency_inversion_principle ).

This is where I found the above definition. Around 50 minutes into the video the instructor explains the above. https://www.youtube.com/watch?v=TMuno5RZNeE