第13讲 面向对象下

property装饰器

• 我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改

常规写法：

#常规写法
class OnePeace():

    def __init__(self,name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self,name):
        self._name = name


ab = OnePeace('路飞')
print(ab._name)    #路飞
print(ab.get_name())    #路飞  get_name的方法
ab.set_name('索隆')
print(ab.get_name())   #索隆   set_name的方法修改属性

运行结果：

双下划綫 __ 私有属性:

#双下划綫 __ 私有属性
class OnePeace():

    def __init__(self,name):
        self.__name = name

    def get_name(self):
        return self.__name

    def set_name(self,name):
        self.__name = name


ab = OnePeace('路飞')
ab.__name = '山治'
print(ab.__name)   #山治  此时的__name实际是重新创建的属性
print(ab.get_name())   #路飞   原有属性，实际原有属性名已被系统设定_OnePeace__name

运行结果：

property的使用

# property的使用1（调用方法不用（）；私有属性）
class OnePeace():

    def __init__(self,name):
        self.__name = name

    @property
    def get_name(self):
        return self.__name

    def set_name(self,name):
        self.__name = name


ab = OnePeace('路飞')
print(ab.get_name)    #路飞  此时调用方法不用再使用()
ab.set_name = '索隆'
print(ab.get_name)   #路飞   property使得属性不得被随意更改

# property的使用2   setter方法声明
class OnePeace():

    def __init__(self,name):
        self.__name = name

    @property
    def get_name(self):
        return self.__name

    @get_name.setter     #get_name是上面声明的方法
    def set_name(self,name):
        self.__name = name


ab = OnePeace('路飞')
print(ab.get_name)    #路飞  此时调用方法不用再使用()
ab.set_name = '索隆'
print(ab.get_name)   #索隆  声明后可以用setter方法修改属性

运行结果：

继承简介

• 继承是面向对象三大特性之一
• 通过继承我们可以使一个类获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性

#继承
class Car(object):

    def __init__(self,brand,model):
        self.brand = brand
        self.model = model

    def function(self):
        print('我有一辆%s的%s,它有座椅加热的功能' %(self.model,self.brand))

    def speed(self,t):
        print('我的那辆%s的%s百公里加速%ss' %(self.model,self.brand,t))


class Moto(Car):    #Car是Moto的父类或基类
    pass


one = Moto('Ducati', 'red')
two = Car('BMW M3','灰色')
one.function()
one.speed(3)
two.speed(3.2)

print(issubclass(Moto, Car))    #True  issubclass（类1，类2） 判断类2是不是类1的父类
print(isinstance(one,Moto))     #True  one是Moto的实例
print(isinstance(one,Car))      #True  one是Moto的实例，Car是Moto的父类，所以也属于Car这个类
print(isinstance(two,Car))      #True  Two是Car的实例
print(isinstance(two,Moto))     #Flase   Car是Moto的父类，父类创造的实例不是子类的实例
print(issubclass(Moto,object))  #True  object是所有类的父类

运行结果：

方法重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
• 当我们调用一个对象的方法时：
  会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了

class Ab():

    def walk(self):
        print('没事走两步')

    def run(self):
        print('跑起来了')

class Cd(Ab):

    def clowd(self):
        print('爬行')

class Ef(Cd):
    pass


cat = Ef()
cat.run()   #父类没有的方法，会继续往父类的父类找，一直找到object
cat.sit()   #如果一直都没有就会报错

运行结果：

class Ab():

    def walk(self):
        print('没事走两步')

    def run(self):
        print('跑了个100m')

class Cd(Ab):

    def clowd(self):
        print('爬行')

class Ef(Cd):

    def run(self):
        print('跑了个1km')


cat = Ef()
cat.run()   #子类和父类用了同名的方法，子类的方法会覆盖父类

super()

• super()可以获取当前类的父类
• 并且通过super()返回对象调用父类方法时，不需要传递self

class Ab():

    def walk(self):
        print('没事走两步')

    def run(self):
        print('跑了个100m')

class Cd(Ab):

    def clowd(self):
        print('爬行')

class Ef(Cd):

    def run(self):
        super().run()
        Cd.run(self)   #等同于此方法，但如果父类方法名改变了，还需要调整，所以用super代替父类
        super(Ef, self).run()  #python2时期的老写法，现在不需要传递self
        print('跑了个1km')


cat = Ef()
cat.run()   #子类和父类用了同名的方法，子类的方法会覆盖父类

运行结果：

多重继承

• 在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
• 可以在类名的()后边添加多个类，来实现多重继承
• 多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
• 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

#多重继承
class Ab(object):

    def walk(self):
        print('没事走两步')

    def run(self):
        print('跑了个100m')

class Cd(object):

    def clowd(self):
        print('爬行')

    def run(self):
        print('跑了个马拉松')


class Ef(Ab, Cd):
    pass


cat = Ef()
cat.run()   #跑了个100m  多重继承，前边会覆盖后边

尽量不要用多重继承，解耦合，尽量减少类的互相联动
运行结果：

多态

• 多态是面向对象的三大特性之一。从字面理解就是多种形态
• 一个对象可以以不同形态去呈现
• 面向对象三大特性
  封装 确保对象中数据的安全
  继承 保证了对象的扩展性
  多态 保证了程序的灵活性
• Python中多态的特点
  1、只关心对象的实例方法是否同名，不关心对象所属的类型；
  2、对象所属的类之间，继承关系可有可无；
  3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；
  4、多态是调用方法的技巧，不会影响到类的内部设计。

#多态   多态只是一种代码的运用方式
class Dog(object):

    def run(self):
        print('狗狗跑起来了')


class Car(object):

    def run(self):
        print('汽车发动了')


def pao(x):   
    x.run()    #类有同名方法时便可使用

Dog1 = Dog()
car1 = Car()

pao(Dog1)  
pao(car1)

运行结果：

属性和方法

• 属性
  类属性，直接在类中定义的属性是类属性
  类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改
  实例属性 通过实例对象添加的属性属于实例属性
  实例属性只能通过实例对象来访问和修改，类对象无法访问修改

class A(object):
    name = 'Tommy'    #类属性

    def __init__(self,age):
        self.age = age      #实例属性

    def run(self):
        print('跑起来了')


abc = A(12)
abc.name = 'Jerry'   #实例属性可以通过实例来修改
print(abc.name, abc.age)   #Jerry，12
print(A.name)   #Tommy  类属性无法修改，只能在类内部修改
print(A.age)

运行结果：

• 方法
  在类中定义，以self为第一个参数的方法都是实例方法
  实例方法在调用时,Python会将调用对象以self传入
  实例方法可以通过类实例和类去调用
  当通过实例调用时，会自动将当前调用对象作为self传入
  当通过类调用时，不会自动传递self，我们必须手动传递self
  类方法 在类的内容以@classmethod 来修饰的方法属性类方法
  类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
  类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
  类方法可以通过类去调用，也可以通过实例调用

class A(object):
    name = 'Tommy'    #类属性

    def __init__(self,age):
        self.age = age      #实例属性

    def run(self):   #形参为self，传参为实例对象
        print('跑起来了')

    @classmethod   #类方法
    def walk(cls):   #形参为cls，即class的缩写
        print('走起来了,类方法')


abc = A(12)
abc.run()
A.run(abc)    #类调用实例方法，需要传参一个self
abc.walk()    #类所有的属性和方法，实例都会继承
A.walk()

运行结果：

• 静态方法
  在类中用@staticmethod来修饰的方法属于静态方法
  静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
  静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
  静态方法一般都是些工具方法，和当前类无关

class A(object):
    name = 'Tommy'    #类属性

    def __init__(self,age):
        self.age = age      #实例属性

    def run(self):   #形参为self，传参为实例对象
        print('跑起来了')

    @classmethod   #类方法
    def walk(cls):   #形参为cls，即class的缩写
        print('走起来了,类方法')

    @staticmethod
    def sit():   #不需要传参，与当前类无任何关系，通常是工具函数，只是保存在当前类中的函数
        print('坐下，静态方法')


abc = A(12)
# abc.run()
# A.run(abc)    #类调用实例方法，需要传参一个self
# abc.walk()    #类所有的属性和方法，实例都会继承
# A.walk()
abc.sit()
A.sit()#实例和类都可以调用

运行结果：