面向对象（封装、继承、多态）

一、面向对象简介

• 面向过程：（Procedure Oriented，简称PO）就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
• 面向对象（Object Oriented，简称OO）是把构成问题的事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事务在整个解决问题的步骤中的行为
• 类：是对现实生活中一类具有共同特征的事物的抽象。类时属性和方法的集合
• 对象：类的实例化可以得到一个对象，对象就是具备了类的属性和方法
• 属性：对象的属性特征
• 方法：对象所具有的能力动作
• 面向对象三大特征：封装、继承和多态

二、封装

• 概念：将数据和操作封装为一个有机的整体，由于类中私有成员都是隐藏的，只向外部提供有限的接口，所以能保证内部的高内聚性与外部的低耦合性。使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员，能顾增强安全性和简化编程。

class PersonClass:
    name = 'zhangsan'  # 属性1
    age = 11           # 属性2
    def study(self):   # 方法1
        print('study')
    def sleep(self):   # 方法2
        print('sleep')


if __name__ == '__main__':
    pc = PersonClass()  # 实例化类得到一个对象pc
    print(pc.name)      # 通过pc对象调用类的属性
    pc.study()          # 通过pc对象调用类的方法

• 私有化：只能自己用。在属性或方法名称前加两个下划线_ _就代表私有化了属性或方法

class PersonClass:
    __name = 'zhangsan'  # 属性1私有化
    age = 11             # 属性2
    def study(self):     # 方法1
        print('study')
    def __sleep(self):   # 方法2私有化
        print('sleep')


if __name__ == '__main__':
    pc = PersonClass()   # 实例化得到一个对象pc
    print(pc.__name)     # 通过pc对象调用类的私有属性
    pc.__study()         # 通过pc对象调用类的私有方法

• 构造方法：类的内置方法。调用类的自定义方法之前运行一次
• 析构方法：类的内置方法。调用类的自定义方法之后运行一次

# 构造方法，析构方法
class PersonClass:
    def __init__(self):    # 构造方法
      print('__init__')
    def study(self):       # 方法1
      print('study')
    def sleep(self):       # 方法2
      print('sleep')
    def __del__(self):     # 析构方法
      print('__del__')


if __name__ == '__main__':
    pc = PersonClass()     # 实例化类得到一个对象pc
    pc.study()             # 通过pc对象调用类的方法

• 属性和方法调用：self

class PersonClass:
    sex = 'man'                 # 正确定义方式
    # self.sex = 'man'          # 错误定义方式
    def __init__(self):         # 构造方法
        self.name = 'zhangsan'  # 正确定义方式
        age = 11                # 错误定义方式
    def study(self):            # 方法1
        print('study')
        print(self.name)        # 正确调用方式
        # print(age)            # 错误调用方式
        print(self.sex)
        self.sleep()
    def sleep(self):
        print('sleep')


if __name__ == '__main__':
    pc = PersonClass()
    pc.study()

三、继承

• 概念：继承性更符合认知规律，使程序更易于理解，同时节省不必要的重复代码。类与类之间才能继承。
• 分类：父类（超类、基类），子类（派生类）
• 继承规则：Python允许多继承。调用顺序：从左到右，先深度再广度

class GrandFather:  # 爷爷类
    def study(self):
        print('GrandFather:study')
class Father(GrandFather):  # 父亲类
    def study(self):
        print('Father:study')
class Father2:  # 二爸类
    def study(self):
        print('Father:study')
class Son(Father,Father2):  # 儿子类
    def study(self):
        print('Son:study')


if __name__ == '__main__':
    s = Son()
    s.study()

• 子类调用父类同名方法：super().method()

class Father:         # 父亲类
    def study(self):
        print('Father:study!')
class Son(Father):    # 儿子类
    def study(self):
        print('Son:study')
        # self.study()   # 子类调用父类方式1：对于同名的方法不适用
        super().study()  # 子类调用父类方式2：对于同名和不同名的方法均使用

if __name__ == '__main__':
    s = Son()
    s.study()

四、多态

• 概念：统一操作作用于不同对象，可以有不同的解释，产生不同的执行结果。让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容（功能）的函数。

class Father:  # 父亲类
    def study(self):
        print('Father:study')
class Son(Father):  # 儿子类
    def study(self):
        print('Son:study')


if __name__ == '__main__':
    def method(obj):
        obj.study()
    f = Father()
    s = Son()
    method(f)  # 多态：使用相同名称的方法，传入不同的对象，展现处不同的结果
    method(s)

• 重写：父类方法不能满足子类的需求时，就可以在子类中重新定义一个同名的方法，就叫重写
• 重载：首先python没有重载。重载是指方法名相同，方法的参数个数、顺序和类型不同，根据方法调用时传入的不同参数来决定具体调用哪个方法。