面向初学者的 OOP 概念：多态性解释

在 Python 和 Java 等高级语言中，OOP 或面向对象编程是指围绕数据和对象而不是逻辑和功能的软件设计组织。 对象被定义为具有独特属性和行为的数据字段。 换句话说，OOP 专注于对象而不是逻辑。 这种编程模型非常适合需要主动更新和维护的大型复杂程序。 此外，它还带来了可扩展性、效率和代码可重用性的额外好处。

OOP 有四个基本构建块——多态、封装、抽象和继承。 由于本文的范围仅限于 OOP 中的多态性，因此我们将详细讨论多态性，包括 Java 中的多态性和 Python 中的多态性示例。

从世界顶级大学在线学习软件课程。 获得行政 PG 课程、高级证书课程或硕士课程，以加快您的职业生涯。

多态性定义

最简单的多态性定义是多态性意味着以各种形式存在。 它起源于两个希腊术语——“poly”，意思是“众多”和“morph”，意思是“形式”。

为了更好地理解这个概念，我们先举一个简单的例子。 以光标行为为例，每次使用鼠标或触控板时，您在屏幕上看到的光标都在移动。 根据用户的动作或程序模式，光标可以采用不同的形式，例如箭头、十字、线或食指。

多态性是 OOP 最重要的特征之一。 在 Java 和 Python 中，变量、对象和函数可以以多种形式存在。 在多态性中，子类或方法定义其属性和行为，同时保留其父类的一些功能。 这将我们带到了继承，它允许您创建类层次结构，其中基类将其属性和行为提供给派生类。 随后，派生类的功能可以根据需要自由修改或扩展。 为此，多态性确保根据调用对象的类型执行正确的方法。

为了正确看待它，假设您有一个显示日期和时间的类。 现在，您创建一个继承类并显示消息“Hello！”的方法。 连同日期和时间。

Java中的多态性示例

考虑具有方法“area()”的超类“Shapes”。 “形状”下的子类可以是“矩形”、“圆形”、“三角形”等，每个子类都有其计算面积的方法。 应用继承和多态的概念，子类使用“area()”方法来找到计算相应形状面积的公式。

类形状{

公共无效区域（）{

System.out.println(“面积公式”);

}

}

类三角形扩展形状{

公共无效区域（）{

System.out.println(“三角形是 1/2 * 底 * 高”);

}

}

类圆形扩展形状{

公共无效区域（）{

System.out.println(“圆为 3.14 * 半径 * 半径”);

}

}

类主{

公共静态无效主要（字符串[]参数）{

形状 myShape = new Shapes(); // 创建一个 Shapes 对象

形状 myTriangle = new Triangle(); // 创建一个三角形对象

形状 myCircle = new Circle(); // 创建一个圆形对象

myShape.area();

myTriangle.area();

myShape.area();

myCircle.area();

}

}

上述程序代码的输出将如下：

三角形的面积公式是 1/2 * 底 * 高

圆的面积公式是 3.14 * 半径 * 半径

OOP 中的多态性类型

OOP 中的多态性有两种类型——静态（编译时多态性）和动态（运行时多态性）。

1. 静态多态

在 Java 中，方法重载是最常见的静态多态类型。 它可以在同一个类中创建多个同名但参数不同的方法。 参数集必须至少在以下三个标准之一方面有所不同：

• 这些方法需要具有不同数量的参数。
• 参数类型需要不同。 例如，如果一种方法接受 Long，则另一种方法接受 String。
• 这些方法应该接受不同顺序的参数。 例如，如果方法 1 接受 Long 和 String，则方法 2 必须接受 String 和 Long。

在方法重载中，在调用方法时，编译器根据调用时传递的参数来选择调用哪个方法。 这发生在编译时，因此，这种类型的多态性也称为编译时多态性。

以下是显示编译时多态性的 Java 代码示例。 在这个例子中，adds() 方法被重载了两种不同类型的参数。

包静态多态；

公共课加法

{

无效总和（int x，int y）

{

诠释 c = x+y;

System.out.println(“两个数相加:” +c); }

无效总和（int x，int y，int z）

{

诠释 c = x+y+z;

System.out.println(“三个数相加：” +c); }

公共静态无效主要（字符串 [] 参数）

{

加法 obj = new Addition();

obj.sum (45,34);

obj.sum(60, 32, 11);

}

}

上述程序的输出将是：

两个数字相加：79

三个数字相加：103

2.动态多态性

动态或运行时多态性是通过方法覆盖来实现的。 在这里，方法在不同的类中有不同的形式（方法覆盖），而不是编译时，对覆盖方法的调用在运行时解决。 现在，在将对象分配给类引用并调用方法后，对象类中的方法就会被执行。 由于对象是在运行时创建的，因此应该执行的方法（在对象中）的形式仅在运行时决定。

以下是显示运行时多态性的 Java 代码示例。 在示例中，有一个超类“Animal”和三个子类“kangaroo”、“tiger”和“fish”。 子类扩展了超类并覆盖了它的“move()”方法。 “move()”方法由父类“Animal”的引用变量调用。

动物类{

无效移动（）{

System.out.println(“动物移动”);

}

}

类袋鼠扩展动物{

无效移动（）{

System.out.println(“袋鼠跳”);

}

}

类老虎扩展动物{

无效移动（）{

System.out.println(“老虎走路”);

}

}

类鱼扩展动物{

无效移动（）{

System.out.println(“鱼游”);

}

}

类主{

公共静态无效主要（字符串参数[]）{

动物 A = 新动物（）；

动物 k = 新袋鼠（）； //向上转型

动物 t = 新老虎（）； //向上转型

动物 f = 新鱼（）； //向上转型

一个动作（）;

k.move();

t.move();

f.move();

}

}

上述程序的输出将是：

动物移动

袋鼠跳

老虎走

鱼游

Python中的多态性

Python中的多态性分为三种类型——运算符多态性、函数多态性和类多态性。 Python 还允许方法覆盖，但不允许方法重载。

1. 算子多态性

在 Python 中，“+”运算符具有双重用途。 它用于整数数据类型的算术加法运算，对于字符串，“+”运算符执行连接。

以下是一个 Python 代码示例，其中“+”运算符对整数数据类型执行加法：

数字1 = 4

数字2 = 5

打印(num1+num2)

上述程序代码的输出是“9”。

以下是一个 Python 代码示例，其中“+”运算符对字符串数据类型执行连接：

str1 = “好”

str2 = “晚上”

打印（str1+” “+str2）

上述程序的输出将是“晚安”。

2.函数多态

Python 中的 'len()' 函数兼容不同的数据类型，如列表、字符串、元组、字典和集合，但返回每种数据类型的特定信息。 这是一个例子：

打印（len（“程序员”））

print(len([“Python”, “Java”, “C”]))

打印（len（{“姓名”：“凯西”，“地址”：“德克萨斯”}））

上面的程序将有以下输出：

9

3

2

3. 类多态

扩展多态性的概念，Python 允许多个类拥有同名的方法。 下面给出了一个显示 Python 中类方法中的多态性的示例。 在示例中，有两个类，“Cat”和“Dog”。 它们具有相似的结构并具有相同的方法名称“make_sound()”和“info()”。

猫类：

def __init__（自我，姓名，年龄）：

self.name = 名称

自我年龄 = 年龄

定义信息（自我）：

print(f“我是一只猫。我的名字是 {self.name}。我是 {self.age} 岁。”)

def make_sound(self):

打印（“喵”）

类狗：

def __init__（自我，姓名，年龄）：

self.name = 名称

自我年龄 = 年龄

定义信息（自我）：

print(f“我是一只狗。我的名字是 {self.name}。我是 {self.age} 岁。”)

def make_sound(self):

打印（“树皮”）

cat1 = 猫（“米妮”，3）

dog1 = 狗（“汤姆”，6）

对于 (cat1, dog1) 中的动物：

动物.make_sound()

动物信息（）

动物.make_sound()

输出如下：

喵

我是一只猫。 我的名字是米妮。 我今年 3 岁。

喵

吠

我是一只狗。 我的名字是汤姆。 我今年 6 岁。

吠

4. 方法覆盖

Python 还允许子类从父类继承属性和方法。 可以重新定义某些方法和属性以适应子类（方法覆盖）。 然后，多态允许访问与父类同名的重写方法和属性。

以下是说明方法覆盖的 Python 代码示例：

从数学导入 pi

类形状：

def __init__(self, name):

self.name = 名称

定义区域（自身）：

经过

事实（自我）：

返回“我是一个封闭的人物。”

def __str__(self):

返回 self.name

类方形（形状）：

def __init__（自我，长度）：

super().__init__(“正方形”)

self.length = 长度

定义区域（自身）：

返回 self.length**2

事实（自我）：

return “正方形的每个角都等于 90 度。”

类圆（形状）：

def __init__（自我，半径）：

super().__init__(“圆”)

self.radius = 半径

定义区域（自身）：

返回 pi*self.radius**2

a = 正方形(4)

b = 圆（7）

打印(b)

打印（b.fact（））

打印（a.fact（））

打印（b.area（））

上面的程序将有以下输出：

圆圈

我是一个封闭的人物。

正方形中的每个角等于 90 度。

153.93804002589985

了解有关方法覆盖的更多信息。

OOP 中多态性的优势

OOP 中的多态性具有三个显着优势。 它们如下：

• 多态性允许代码的可重用性。 因此，一旦编写、测试和实现了类，您就可以一次又一次地重用它们。 另外，可以更改代码而不影响原始代码。 所有这些都为编码人员节省了大量时间。

• 在多态性中，多个数据值可以存储在单个变量中。 此外，可以修改从超类继承到子类的变量值，而无需更改超类或任何子类中的变量值。

• 最后，多态性使用更少的代码行，这反过来又使程序员更容易调试。

前进之路

upGrad 与著名的利物浦约翰摩尔斯大学合作，提供严格的在线数据科学理学硕士课程 适用于有志于从事数据科学事业的在职专业人士。 该课程以 LJMU 的硕士学位和 IIIT Bangalore 的执行 PG 计划认证结束。

节目亮点：

• 500 多个小时的内容、60 多个案例研究和项目、20 多个现场会议
• 全面覆盖 Python、AWS、MySQL 等 14 多种工具和软件
• 与行业专家的辅导课程
• 同行学习和行业网络
• 360 度职业协助

作为当今最好的高等教育科技平台之一，upGrad 继续通过结合尖端技术、最新教学法、行业合作伙伴关系和世界一流的教师来激励和培养学习者。

从世界顶级大学在线学习数据科学课程。 获得行政 PG 课程、高级证书课程或硕士课程，以加快您的职业生涯。