Python面向对象编程（五）

最新推荐文章于 2024-06-13 07:17:42 发布

mx丶姜小辉

最新推荐文章于 2024-06-13 07:17:42 发布

阅读量954

点赞数

分类专栏： Python面向对象编程系列文章标签： Python 面向对象编程

本文链接：https://blog.csdn.net/qq_40304090/article/details/80340506

版权

Python面向对象编程系列专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、继承父类属性和方法

1. 继承

面向对象的编程带来的好处之一是代码的重用，实现这种重用方法之一是通过继承机制。继承（Inheritance）是两个类或多个类之间的父子关系，子类继承了父类的所有公有数据属性和方法，并且可以通过编写子类的代码扩充子类的功能。想象一下，如果人类可以做到子女继承父母的所有才学并加以扩展，那么人类的发展至少是现在的数万倍。继承实现了数据属性和方法的重用，减少了代码的冗余度。
在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承自狗。

特定狗种类继承狗类，狗类继承动物类，狗类编写了描述所有狗种共有的行为和方法，而特定狗种类则增加了该狗种特有的行为。不过继承也有一定弊端，可能父类对于子类也有一定特殊的地方，如某种特定狗种不具有绝大部分狗种的行为，当程序员没有理清类间的关系时，可能使得子类具有了不该有的方法。另外，如果继承链太长的话，任何一点小的变化都会引起一连串变化，使用的继承要注意控制继承链的规模。
在Python中继承有以下一些特点。
(1) 在继承中基类初始化方法__init__不会被自动调用。如果希望子类调用基类的__init__方法，需要在子类的__init__方法显示调用它。这与C++和C#区别很大。
(2) 在调用基类的方法时，需要加上基类的类名前缀，且带上self参数变量。注意在类中调用在该类定义的方法是不需要self参数的。
(3) Python总是首先查找对应类的方法，如果在子类没有对应的方法，Python才会在继承链的基类中按顺序查找。
(4) 在Python继承中，子类不能访问基类的私有成员。
最后一次修改类Cat的代码。
>>>class Cat():
... def __init__(self):
... self.name = '猫'
... self.age = 4
... self.info = [self.name,self.age]
... self.index = -1
... def run(self):
... print( self.name,'--在跑')
... def getName(self):
... return self.name
... def getAge(self):
... return self.age
... def __iter__(self):
... print('名字年龄')
... return self
... def next(self):
... if self.index == len(self.info)-1:
... raise StopIteration
... self.index += 1
... return self.info[self.index]
>>>class Bosi(Cat):
... def setName(self, newName):
... self.name = newName
... def eat(self):
... print( self.name,'--在吃')
...
>>>bs = Bosi() # 创建对象
>>>print( 'bs的名字为:',bs.name) # 继承父类的属性和方法
bs的名字为: 猫
>>>print( 'bs的年龄为:',bs.age)
bs的年龄为: 4
>>>print(bs.run())
猫 --在跑
>>>bs.setName('波斯猫') # 子类的属性和方法
>>>bs.eat()
波斯猫 --在吃
>>>iterator = iter(bs.next,1) # 迭代输出父类的属性
>>>for info in iterator:
... print(info)
猫
4
定义了Bosi类的父类Cat，将猫共有的属性和方法都放到父类中，子类仅仅需要向父类传输数据属性即可。这样做可以很轻松地定义其他基于Cat类的子类。因为假如有数百只猫，使用继承的方法大大减少了代码量，且当需要对全部猫整体修改时仅需要修改Cat类即可。Bosi类的__init__函数中显示调用了Cat类的__init__函数，并向父类传输数据，这里注意要加self参数。
在继承里面不能继承父类的私有属性，所以也不用担心父类和子类出现因继承造成的重名情况。为了能更清晰地讲述这个问题，这里再举一个例子。
>>>class animal():
... def __init__(self,age):
... self.__age = age
... def print2(self):
... print(self.__age)
>>>class dog(animal):
... def __init__(self,age):
... animal.__init__(self,age)
... def print2(self):
... print(self.__age)

>>>a_animal = animal(10)
>>>a_animal.print2()
10
>>>a_dog = dog(10)
>>>a_dog.print2() # 程序报错
AttributeError: 'dog' object has no attribute '_dog__age'

2. 多继承

如果有多个父类，则父类名需要全部都写在括号里，这种情况称为多继承，格式为Class子类名（父类名1，父类名2，•••）。
>>>class A(object): # 定义一个父类
... def __init__(self):
... print (" ->Input A")
... print (" <-Output A")
>>>class B(A): # 定义一个子类
... def __init__(self):
... print (" -->Input B")
... A.__init__(self)
... print (" <--Output B")
>>>class C(A): # 定义另一个子类
... def __init__(self):
... print (" --->Input C")
... A.__init__(self)
... print (" <---Output C")
>>>class D(B, C): # 定义一个子类
... def __init__(self):
... print ("---->Input D")
... B.__init__(self)
... C.__init__(self)
... print ("<----Output D")

>>>d = D() # Python中是可以多继承的，父类中的方法、属性，子类会继承。
---->Input D
-->Input B
->Input A
<-Output A
<--Output B
--->Input C
->Input A
<-Output A
<---Output C
<----Output D
>>>issubclass(C,B) # 判断一个类是不是另一个类的子孙类
False
>>>issubclass(C,A)
True
实现继承之后，子类将继承父类的属性，也可以使用内建函数issubclass函数来判断一个类是不是另一个类的子孙类，前项参数为子类，后项参数为父类。

二、掌握其他方法

面向对象的三大特性是指重载、封装和多态。

1. 重载

所谓重载，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法。
>>>class Cat:
... def sayHello(self):
... print("喵-----1")
>>>class Bosi(Cat):
... def sayHello(self):
... print("喵喵----2")

>>>bosi = Bosi()
>>>bosi.sayHello() # 子类中的方法会覆盖掉父类中同名的方法
喵喵----2

2. 封装

既然Cat实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Cat类的内部定义访问数据的函数。这样，就把数据给“封装”起来了。
封装（Encapsulation）就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是通过外部接口，特定的访问权限来使用类即可。简而言之，就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

3. 多态

多态性（Polymorphism）是对象通过他们共同的属性和动作来操作及访问，允许将父对象设置成和一个或多个它的子对象相等的技术，比如Car=Land_Rover。多态性使得能够利用同一类(父类)类型的指针来引用不同类的对象，以及根据所引用对象的不同，以不同的方式执行相同的操作。

Python是动态语言，可以调用实例方法，不检查类型，只要方法存在，参数正确就可以调用，这就是与静态语言（例如Java）最大的差别之一。表明了动态（运行时）绑定的存在，允许重载或运行时类型确定和验证。

三、练习

在创建的Car类上产生子类Land_Rover，要使子类Land_Rover拥有2个父类属性（品牌、颜色）和两个自带属性（车轮数、废气涡轮增压），然后输出子类属性。

参考代码：

class Car():
def __init__(self,brand, newWheelNum, newColor,T):
self.brand = brand
self.wheelNum = newWheelNum
self.color = newColor
self.T = T # T为废气涡轮增压
self.info = [self.brand,self.wheelNum,self.color,self.T]
self.index = -1
def getBrand(self):
return self.brand
def getNewheelnum(self):
return self.wheelNum
def getNewcolor(self):
return self.color
def getT(self):
return self.T
def __iter__(self):
print('品牌车轮数颜色废气涡轮增压')
return self
def next(self):
if self.index == 3:
raise StopIteration
self.index += 1
return self.info[self.index]

class Land_Rover(Car):
def __init__(self,brand, newColor):
self.brand = brand
self.wheelNum = 4
self.color = newColor
self.T = 3
Car.__init__(self,self.brand,self.wheelNum,self.color,self.T)

Luxury_car = Car('BMW',4, 'green',2.4) # 创建对象
print(Luxury_car.getNewcolor()) # 访问属性
iterator = iter(Luxury_car.next,1) # 调用迭代函数
for info in iterator:
print(info)