面向对象总结

面向对象
    一切以对象为中心. 侧重关注的是对象, 在面向对象的世界里. 你就是上帝. 你需要什么就些什么
        优点: 可扩展性比较大. 容易理解
        缺点: 上手比较难

面向过程(函数式编程)
    一切以我为中心. 侧重关注的是事务发展流程.
        优点: 好理解. 简单
        缺点: 可控性比较差. 扩展性比较差

对象: 一切都是对象. 现实生活中的具体的实物. 你脑袋里想想的一个东西
创建对象: 先创建类. 使用类实例化成对象
类: 归类
    成员:
        1. 变量
            实例变量: 对象.变量
            类变量(静态变量): 类名.变量
        2. 方法
            实例方法                def 实例方法(self)         对象.方法()
            类方法  @classmethod    def 类方法(cls):pass       类名.方法()
            静态方法 @staticmethod   def 静态方法():           类名.方法()
        3. 属性
            把一个方法改变成属性
            @property
            def age(self):
                return 2018 - self.birthday

用类创建对象
    类名() 默认执行 def __init__(self, xxxxxxxx)  初始化方法(构造方法)  __new__() 真正的构造方法
    p = Person("张三")
    p2 = Person("李四")
    两个对象拥有两个独立的名称空间. 拥有独立的内存地址

    在用对象去访问方法的时候. 要注意self. self是当前正在执行该方法的对象
    p.chi()
    p2.chi()

    类是对象的归类.  对象是类的具体

    对象是通过类来创建的.  类是type创建的
    python中所有的东西都是由object造的

    object是所有的类的根

    面向对象三个特征:
        1. 封装  -> 封装类
            1. 对数据的封装
                def __init__(self, name, age, hobby):
                    self.name = name
                    self.age = age
                    self.hobby = hobby

             2. 对方法和功能的封装
                class Excel:
                    def read():
                        pass
                    def write():
                        pass
                    def create_sheet():
                        pass
        2. 继承
            python多继承. 当出现复杂的继承关系的时候. 观察MRO (Method Resolution Order).
            如果没有复杂的多继承. 先找亲爹. 再找干爹

            super().方法()  执行MRO 中的下一个

        3. 多态
            python直接就是多态
            python中的多态. 遵循的是鸭子模型. 多态性是面向对象的核心.
            多态 -> 面向对象的核心 -> 面向对象编程的核心

类与类之间的关系
    1. 依赖关系   临时工
        通过方法的参数把另一个类的对象传递进来.
        两个类之间的关系是最轻的

        我需要你. 但你不属于我

    2. 关联关系
        我需要你. 你还得属于我

        def __init__(self, teacher):
            self.teacher = teacher

        一对一的关系    你和你的身份证
        一对多的关系    老师和学生的关系
        多对多的关系    学生和课程
                        学生:          sc               课程
                            sno        sno                 cno
                            sname      cno                 cname
                            sage       score               ctime
                            sgender

                         学生表: sno, sname, sage, sgender
                                   1   朱元璋  18   男
                                   2   朱棣    20   男
                                   3   朱允炆  13   男
                                    4  朱高炽   16   男
                                    5  朱嶦基    50   男

                          sc表 sno, cno
                                1    1    80
                                1    2    160
                                2    1    80
                                2    3    30


                          课程: cno   cname   ctime
                                1      体育课  昨天
                                2      体活课  昨天
                                3      美术课  昨天
        组合关系
        聚合关系
           从代码上来看 关联关系, 组合关系, 聚合关系. 都是一样的写法. 当你做设计. 类图是不一样的(UML)

反射
    hasattr(对象, 字符串)
    getattr(对象, 字符串)
    setattr(对象, 字符串, 值)
    delattr(对象, 字符串)

    issubclass 判断xxx类是否是xxx的子类
    isinstance 判断 xxx是否是xxx类型(向上)
    type   获取到对象的类型

    方法和函数
        实例方法
            1. 对象.方法  方法
            2. 类.方法   函数
        类方法
            都是方法
        静态方法
            都是函数

        from types import FunctionType, MethodType
        isinstance


约束, 父类对子类的约束:
    抛出异常,NotImplementedError
    抽象类和抽象方法
    from abc import ABCMeta, abstractmethod
    class 类(metaclass = ABCMeta)
        @abstractmethod
        def 方法(self): pass

    抽象类一般不创建对象. 如果抽象类中包含抽象方法则不能创建对象


    异常处理;
        import traceback
        try;
            xxxx
        except 错误 as e:
            logging.error(traceback.format_exc())
        finally:
            收尾

    抛异常
        raise 异常()

    class 你自己的异常(Exception):
        pass


工厂设计模式

class Person:
    pass

class PersonFactory: # 工厂类

    @staticmethod
    def create_person(): # 造人
        return Person()

p = PersonFactory.create_person()

class Car:
    def shenghaizi(self):
        pass