python学习记录21

1 面向对象的三大特征

面向对象的三大特征为：封装、继承、多态。

（1）封装

封装是指在类的使用中对隐藏内部细节，只提供操作方法的操作。例如在定义实例方法时，你无法看到我这个方法是用什么函数描述的，但是知道我这个方法的名字和作用。目的是为了保证数据安全。这种封装也可以叫做权限控制。python中没有明确的权限访问修饰符，是通过对属性和方法添加单下划线、双下划线以及首尾下划线实现的

单下划线：这类成员只限内部访问，只允许类本身和子类去访问，但事实上外部代码还是可以强行访问的

双下划线：代表是私有成员，只允许定义该属性或方法的类本身访问,使用对象访问的方法有：

对象名._类名__方法或属性#不推荐

使用修饰词@property将方法转化为属性，此时属性值只能查看不能直接修改#推荐

首尾双下划线：特殊的方法（例如初始化方法）

python 复制代码

class Car:
    def __init__(self,name,price):
        self._name = name#受保护的对象
        self.__price = price#私有对象
    def _fun1(self):
        print('1')
    def __fun2(self):
        print("2")
    def sh(self):
        self._fun1()
        self.__fun2()
        print(self._name)
        print(self.__price)
a = Car('benz',40000)
print(a._name)
print(a._Car__price)#不推荐的方法
a._fun1()
a._Car__fun2()#不推荐的方法

使用修饰词进行属性控制,属性值可以使用setter方法去修改

python 复制代码

class Car:
    def __init__(self,name,price):
        self._name = name#受保护的对象
        self.__price = price#私有对象
    @property
    def jiage(self):
        return self.__price
    @jiage.setter#更改属性值
    def jiage(self,value):
        self.__price=value
a =Car('Benz',400000)
print(a._name,a.jiage)
b =Car("BMW",300000)
b.jiage =600000
print(b.jiage)

（2）继承

在函数调用时使用形参名=值的方式经行传参，这就是一种继承的方法。Python中可以用一个新类继承一个旧类，此时新类不仅拥有旧类的属性和方法，还能有自己的属性和方法。在Python中被继承的类称为父类或基类，继承的类叫做子类。一个子类可以继承多个父类（python特性），一个父类可以拥有多个子类。如果一个类没有继承任何类，则默认其继承的是object类。

继承的语法结构为：

class 继承的子类（父类1，父类2，......，父类N）：

一个子类可以继承多个多个父类，以及多个父类的属性与方法，这个性质我们叫做多继承。

python 复制代码

class Car:
    def __init__(self,price):
        self.price =price
class Benz(Car):
    def __init__(self,price,version):
        super().__init__(price)#继承父类的初始属性
        self.version = version#自身的新属性
    def sh(self):
        print(self.version,self.price)
class BMW(Car):
    def __init__(self,price,version,sale):
        super().__init__(price)
        self.version =version
        self.sale =sale
    def sh(self):
        print(self.version, self.price,self.sale)
class Maybach(Benz):
    def __init__(self,price,version,host):
        super().__init__(price,version)
        self.host =host
class House:
    def __init__(self,name):
        self.house = name
class Person(Car,House):#多继承
    def __init__(self,price,name,xingming):
        Car.__init__(self,price)
        House.__init__(self,name)
        self.name = xingming
a = Car(560000)
b = Benz(400000,'GLC')
c = BMW(1200000,'Mpower',500)
d = Maybach(3000000,'GLS','xiaoming')
lst = [a,b,c,d]
for item in lst:
    print(item.price)
e = Person(500000,'biguiyuan','xiaohong')
print(e.price,e.house,e.name)

继承有一个功能称为方法重写，即子类在继承父类时，拥有父类所有对象，包括保护的与受保护的。但父类中的一些方法可能性并不能完全满足子类所需，此时子类可以对父类的方法进行重写。子类重新编写的方法的方法名必须与父类相同（继承），子类自行编写方法体（方法重写）。子类在重新编写父类的方法是使用super.xxx():调用父类的方法。但子类不一定需要继承父类的方法，可以自己完全重写，当系统发现方法时首先调查的是子类的方法。

python 复制代码

class Car:
    def __init__(self,price):
        self.price =price
    def show(self):#父类的方法
        print('价格为：',self.price)
class Benz(Car):
    def __init__(self,price,version):
        super().__init__(price)
        self.version = version
    def show(self):
        print(f'奔驰车的型号为：',self.version)#重写自己的方法以输出自己的属性
        super().show()  # 继承父类的方法
class BMW(Car):
    def __init__(self,price,version,sale):
        super().__init__(price)
        self.version =version
        self.sale =sale
    def show(self):
        print(f'宝马车的型号为：',self.version,f'已售出：',self.sale)#完全重写show方法
a = Benz(500000,'AMG')
a.show()
b = BMW(400000,'M3',300)
b.show()

（3）多态

多态指多种形态，在传参前不需要做出决定需要输入对象的类型，而是在调用对象方法时动态决定类型，即系统只在意这个对象是否具有这样的方法而不在意是否存在继承（java的继承与多态必不可少）。

python 复制代码

class Benz:
    def __init__(self,price):
        self.price =price

class BMW:
    def __init__(self,price):
        self.price =price

class AITO:
    def __init__(self,price):
        self.price =price

def fun(x):
    print(x.price)
a = BMW(100000)
b = Benz('100000')
c = AITO([500000,300000])
fun(a)
fun(b)
fun(c)