python技术栈（七爪源码改进你的）
python技术栈（七爪源码改进你的）多态性：继承的重要好处是代码重用和降低程序的复杂性。 派生类可以（后代）覆盖或扩展基类（祖先）的功能。派生类继承了基类的功能。派生类修改基类的现有行为。最后，派生类通过定义一个新的 bark() 方法扩展了基类的功能。
遗产：
虽然面向对象编程作为一种建模工具很有用，但当引入继承的概念时，它真正获得了力量。 继承是“子”类派生“父”类的数据和行为的过程。 一个例子肯定会对我们有所帮助。
现在让我们使用以下方法创建一个名为“Animal”的类：
- whoAmI
- eat
class Animal:
def __init__(self):
print("Animal created")
def whoAmI(self):
print("Animal")
def eat(self):
print("Eating")class Dog(Animal):
def __init__(self):
Animal.__init__(self)
print("Dog created")
def whoAmI(self):
print("Dog")
def bark(self):
print("Woof!")
--------------------------------------------
d = Dog()Output:
Animal created
Dog createdd.whoAmI()Output:
Dogd.eat()Output:
Eatingd.bark()Output:
Woof!
在这个例子中，我们有两个类：Animal 和 Dog。 Animal 是基类， Dog 是派生类。
派生类继承了基类的功能。
- 它由eat() 方法显示。
派生类修改基类的现有行为。
- whoAmI() 方法显示。
最后，派生类通过定义一个新的 bark() 方法扩展了基类的功能。
继承的重要好处是代码重用和降低程序的复杂性。 派生类可以（后代）覆盖或扩展基类（祖先）的功能。
多态性：
多态只是意味着有多种形式，在这里不同的对象类可以共享相同的方法名，即使可能传入各种不同的对象，这些方法也可以从同一个地方调用。
让我们通过一个简单的例子来理解它：
class Dog:
def __init__(self name):
self.name = name
def speak(self):
return self.name ' says Woof!'
class Cat:
def __init__(self name):
self.name = name
def speak(self):
return self.name ' says Meow!'
niko = Dog('Niko')
felix = Cat('Felix')
print(niko.speak())
print(felix.speak())Output:
Niko says Woof!
Felix says Meow!
这里我们有一个 Dog 类和一个 Cat 类，每个类都有一个 .speak() 方法。 调用时，每个对象的 .speak() 方法都会返回该对象唯一的结果。
有几种不同的方法可以证明多态性。 首先，使用 for 循环：
class India():
def capital(self):
print("New Delhi is the capital of India.")
def language(self):
print("Hindi is the most widely spoken language of India.")class USA():
def capital(self):
print("Washington D.C. is the capital of USA.") def language(self):
print("English is the primary language of USA.")obj_ind = India()
obj_usa = USA()for country in (obj_ind obj_usa):
print(country.capital())
print(country.language())Output:New Delhi is the capital of India.
Hindi is the most widely spoken language of India.
Washington D.C. is the capital of USA.
English is the primary language of USA.
另一个是功能：
def func(obj):
obj.capital()
obj.language()obj_ind = India()
obj_usa = USA()func(obj_ind)
func(obj_usa)Output:New Delhi is the capital of India.
Hindi is the most widely spoken language of India.
Washington D.C. is the capital of USA.
English is the primary language of USA.
这里我们有一个 Dog 类和一个 Cat 类，每个类都有一个 .speak() 方法。 调用时，每个对象的 .speak() 方法都会返回该对象唯一的结果。
有几种不同的方法可以证明多态性。 首先，使用 for 循环：
class India():
def capital(self):
print("New Delhi is the capital of India.")
def language(self):
print("Hindi is the most widely spoken language of India.")class USA():
def capital(self):
print("Washington D.C. is the capital of USA.") def language(self):
print("English is the primary language of USA.")obj_ind = India()
obj_usa = USA()for country in (obj_ind obj_usa):
print(country.capital())
print(country.language())Output:New Delhi is the capital of India.
Hindi is the most widely spoken language of India.
Washington D.C. is the capital of USA.
English is the primary language of USA.
另一个是功能：
def func(obj):
obj.capital()
obj.language()obj_ind = India()
obj_usa = USA()func(obj_ind)
func(obj_usa)Output:New Delhi is the capital of India.
Hindi is the most widely spoken language of India.
Washington D.C. is the capital of USA.
English is the primary language of USA.
在这两种情况下，我们都能够传入不同的对象类型，并且我们从相同的机制中获得了特定于对象的结果。
结论：
面向对象的编程一开始可能非常棘手，但如果理解正确，我们会发现它非常有用，因为它允许我们重用代码并定义结构以确保一致性。
希望大家觉得有用……
关注七爪网，获取更多APP/小程序/网站源码资源！
