OOP

OOP

• 面向对象的编程
• 一切皆对象，每种对象都有一些相关的属性
• 类class：它是一个蓝图，描述了某一对象有哪些属性和行为。
• 实例、对象：通过类创建具体的实例、对象。
• 方法：本质上是函数，定义在类中的函数叫方法。
• 类名建议采用驼峰的形式，也就是每个单词首字母大写，如MyClass
• 类中定义的方法需要绑定在具体的实例,由实例调用

class Role:
    '类声明'
    def __init__(self, name, weapon):
        '该方法被称作构造器方法，用于将属性绑定在实例身上'
        # self不是关键字，可以是任意的合法名称
        self.name = name
        self.weapon = weapon

    def show_me(self):
        # 绑定在实例身上的属性，可以用在类中的任何地方
        print('我是%s，我擅用%s' % (self.name, self.weapon))

if __name__ == '__main__':
    # 根据类创建出具体的实例，自动调用__init__方法，实例将自动作为第一个参数
    lb = Role('吕布', '方天画戟')
    print(lb.name)
    print(lb.weapon)
    lb.show_me()

组合

• 类被定义后,目标就是要把它当成一个模块来使用, 并把这些对象嵌入到你的代码中去
• 组合就是让不同的类混合并加入到其它类中来增加功能和代码重用性
• 可以在一个大点的类中创建其它类的实例,实现一些其它属性和方法来增强对原来的类对象

组合应用

• 两个类明显不同
• 一个类是另一个类的组件

class Role:
    '类声明'
    def __init__(self, name, weapon):
        '该方法被称作构造器方法，用于将属性绑定在实例身上'
        # self不是关键字，可以是任意的合法名称
        self.name = name
        self.weapon =weapon

    def show_me(self):
        # 绑定在实例身上的属性，可以用在类中的任何地方
        print('我是%s，我擅用%s' % (self.name, self.weapon.wname))

class Weapon:
    def __init__(self, wname, strength):
        self.wname = wname
        self.strength = strengt
        
if __name__ == '__main__':
    ji = Weapon('方天画戟', 100)
    lb = Role('吕布', ji)
    print(lb.name)
    print(lb.weapon.wname)
    print(lb.weapon.strength)
    lb.show_me()

继承

• 继承描述了基类的属性如何“遗传”给派生类
• 子类可以继承它的基类的任何属性,不管是数据属性还是方法

子类：

• 当类之间有显著的不同，并且较小的类是较大的类所需要的组件时组合表现得很好；但当设计“相同的类但有一些不同的功能”时，派生就是一个更加合理的选择了
• OOP的更强大方面之一是能够使用一个已经定义好的类，扩展它或者对其进行修改，而不会影响系统中使用现存类的其它代码片段
• OOP(面向对象设计）允许类特征在子孙类或子类中进行继承
• 子类也可以定义自己的方法
• 创建子类只需要在括号中写入父类名称即可

通过继承覆盖方法

• 字类中有和父类同名的方法时，父类的方法将被覆盖

class Role:
    '类声明'
    def __init__(self, name, weapon):
        '该方法被称作构造器方法，用于将属性绑定在实例身上'
        # self不是关键字，可以是任意的合法名称
        self.name = name
        self.weapon =weapon

    def show_me(self):
        # 绑定在实例身上的属性，可以用在类中的任何地方
        print('我是%s，我擅用%s' % (self.name, self.weapon.wname))

class Worrios(Role):
    def __init__(self,name,weapon,health):   #父类中的方法将被覆盖
        Role.__init__(self,name,weapon)    #调用父类中的方法
        Worrios.health = health

    def attack(self, target):
        print('近战攻击: %s' % target)
        
if __name__ == '__main__':
    lb = Worrios('吕布', '矛', 200)
    print('name: %s, wuqi: %s, HP: %s' % (lb.name, lb.weapon, lb.health))
    lb.attack('dc')

多重继承

• 一个类可以是多个类的子类，子类拥有所有父类的属性
• 子类的实例查找方法时，顺序为从下到上，从左到右

class A:
    def func1(self):
        print('A func')

    def func4(self):
        print('A 4')

class B:
    def func2(self):
        print('B func')

    def func4(self):
        print('B 4')

class C(B, A):   # B在左，优先B
    def func3(self):
        print('C func')

if __name__ == '__main__':
    c1 = C()
    c1.func1()
    c1.func2()
    c1.func3()
    c1.func4()  #此时该子类中没有该方法，所以向上查找

特殊方法

• 在class中，有很多以双下划线开头和结尾的方法，这些都是特殊方法，也被称作
  魔法方法magic。

• 常用特殊方法：__init__/__str__/__call__

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return '《%s》' % self.title

    def __call__(self):
        print('《%s》是%s所著' % (self.title, self.author))

if __name__ == '__main__':
    pybook = Book('Python教程第三版', 'Magnus Lie Hetland')
    #在打印时，将自动调用__str__方法
    print(pybook)
    #使实例像函数一样可以调用，调用__call__方法
    pybook()