python-面向对象(2)

1. 面向对象三大特性

  • 封装
  • 继承
  • 多态

1.1 封装

  • 封装就是对对象的成员进行访问限制
  • 封装三个级别
    • 公开
    • 受保护的
    • 私有的
  • 判别对象位置
    • 对象内部
    • 对象外部
    • 子类中
  • python中下划线使用
  • 私有

    • 私有成员是最高级别的封装，只能在当前类或对象中访问

    • 在成员前面添加两个两个下划线即可

        class Person():
      # name是共有的成员 
      name = "liuying"
      # __age就是私有成员
      __age = 18

    • Python的私有不是真私有，是一种成为name mangling的改名策略可以使用 obj._classname_attributename 访问

  • 受保护的封装 protected
    • 受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都可以进行访问，但是在外部不可以(其他模块中不能使用)
    • 封装方法： 在成员名称前添加一个下划线即可
  • 公开的，公共的 public
    • 公共的封装实际对成员没有任何操作，任何地方都可以访问

1.2 继承

  • 继承就是一个类可以获得另外一个类中的成员属性和成员方法

  • 作用： 减少代码，增加代码的复用功能， 同时可以设置类与类直接的关系

  • 继承与被继承的概念：

    • 被继承的类叫父类，也叫基类，也叫超类
    • 用于继承的类，叫子类，也叫派生类
    • 继承与被继承一定存在一个 is-a 关系

  • 继承的语法

  • 案例1

          # 继承的语法
      # 在python中，任何类都有一个共同的父类叫object

      class Person():
          name = "NoName"
          age = 18
          __score = 0 # 考试成绩是秘密，只要自己知道
          _petname = "sec" #小名，是保护的，子类可以用，但不能公用
          def sleep(self):
              print("Sleeping ... ...")
  
      #父类写在括号内
      class Teacher(Person):
          teacher_id = "9527"
          def make_test(self):
              print("attention")
  
      t = Teacher()
      print(t.name)
      # 受保护不能被其他模块访问，本类和子类中都可以访问
      print(t._petname)

      # 私有访问问题
      # 公开访问私有变量，报错
      #print(t.__score)

      t.sleep()
      print(t.teacher_id)
      t.make_test()
      >>>
      NoName
      sec
      Sleeping ... ...
      9527
      attention

  • 案例2

          #子类和父类定义同一个变量，则优先使用子类变量，子类中找不到再去父类中找，一层一层往上找
      class Person():
          name = 'noname'
          age = 18
      class Teacher(Person):
          teacher_id = '9527'
          name = 'cc'
      t = Teacher()
      print(t.name)
      print(t.age)
      >>>
      cc
      18

  • 继承的特征

    • 所有的类都继承自object类，即所有的类都是object类的子类
    • 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
    • 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
    • 子类中可以定义独有的成员属性和方法
    • 子类中定义的成员和父类成员如果相同，则优先使用子类成员
    • 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，可以使用 [父类名.父类成员] 的格式来调用父类成员，也可以使用super().父类成员的格式来调用

  • 案例

          # 子类扩充父类功能的案例
      # 人由工作的函数， 老师也由工作的函数，但老师的工作需要讲课
      class Person():
          name = "NoName"
          age = 18
          __score = 0 # 考试成绩是秘密，只要自己知道
          _petname = "sec" #小名，是保护的，子类可以用，但不能公用
          def sleep(self):
              print("Sleeping ... ...")
          def work(self):
              print("make some money")
  
      #父类写在括号内
      class Teacher(Person):
          teacher_id = "9527"
          name = "DaNa"
          def make_test(self):
              print("attention")
  
          def work(self):
              # 扩充父类的功能只需要调用父类相应的函数
              #Person.work(self)
              # 扩充父类的另一种方法
              # super代表得到父类
              super().work()
              self.make_test()
  
      t = Teacher()
      t.work()
      >>>
      make some money
      attention

  • 继承变量函数的查找顺序问题

    • 优先查找自己的变量
    • 没有则查找父类
    • 构造函数如果本类中没有定义，则自动查找调用父类构造函数
    • 如果本类有定义，则不在继续向上查找

  • 构造函数

    • 是一类特殊的函数，在类进行实例化之前进行调用
    • 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
    • 如果没定义，则自动查找父类构造函数
    • 如果子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造

  • 案例

          class Animel():
          def __init__(self):
              print("Animel")

      class PaxingAni(Animel):
          def __init__(self):
              print(" Paxing Dongwu")

      class Dog(PaxingAni):
          # __init__就是构造函数
          # 每次实例化的时候，第一个被自动的调用
          # 因为主要工作是进行初始化，所以得名
          def __init__(self):
              print("I am init in dog")
  
      # 实例话的时候，自动调用了Dog的构造函数
      # 因为找到了构造函数，则不在查找父类的构造函数
      kaka = Dog()

      # 猫没有写构造函数
      class Cat(PaxingAni):
          pass

      # 此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数
      # 在PaxingAni中查找到了构造函数，则停止向上查找
      c = Cat()
      >>>
      I am init in dog
       Paxing Dongwu

  • super

    • super不是关键字， 而是一个类
    • super的作用是获取MRO（MethodResolustionOrder）列表中的第一个类
    • super于父类直接没任何实质性关系，但通过super可以调用到父类
    • super使用两个方法,参见在构造函数中调用父类的构造函数

  • 单继承和多继承

    • 单继承：每个类只能继承一个类
    • 多继承，每个类允许继承多个类

  • 单继承和多继承的优缺点

    • 单继承：
      • 传承有序逻辑清晰语法简单隐患少呀
      • 功能不能无限扩展，只能在当前唯一的继承链中扩展
    • 多继承：
      • 优点：类的功能扩展方便
      • 缺点：继承关系混乱

  • 案例

          # 多继承的例子
      # 子类可以直接拥有父类的属性和方法，私有属性和方法除外
      class Fish():
          def __init__(self,name):
              self.name = name
          def swim(self):
              print("i am swimming......")

      class Bird():
          def __init__(self, name):
              self.name = name

          def fly(self):
              print("I am flying.....")

      class Person():
          def __init__(self, name):
              self.name = name

          def work(self):
              print("Working........")




      # 单继承的例子      
      class Student(Person):
          def __init__(self, name):
              self.name = name
      stu = Student("yueyue")
      stu.work()


      # 多继承的例子  
      class SuperMan(Person, Bird, Fish):
          def __init__(self, name):
              self.name = name


      class SwimMan(Person, Fish):
          def __init__(self, name):
              self.name = name

      s = SuperMan("yueyue")
      s.fly()
      s.swim()
      >>>
      Working........
      I am flying.....
      i am swimming......

  • 菱形继承/钻石继承问题

    • 多个子类继承自同一个父类，这些子类由被同一个类继承，于是继承关系图形成一个菱形图谱
    • MRO
    • 关于多继承的MRO
      • MRO就是多继承中，用于保存继承顺序的一个列表
      • python本身采用C3算法来多多继承的菱形继承进行计算的结果
      • MRO列表的计算原则：
        • 子类永远在父类前面
        • 如果多个父类，则根据继承语法中括号内类的书写顺序存放
        • 如果多个类继承了同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类

  • 构造函数

    • 在对象进行实例化的时候，系统自动调用的一个函数叫构造函数，通常此函数用来对实例对象进行初始化
    • 构造函数一定要有，如果没有，则自动向上查找，按照MRO顺序，直到找到为止

1.3 多态

  • 多态就是同一个对象在不同情况下有不同的状态出现

  • 多态不是语法，是一种设计思想

  • 多态性： 一种调用方式，不同的执行效果

  • 多态： 同一事物的多种形态，动物分为人类，狗类，猪类

  • 多态和多态性

  • Mixin设计模式

  • 我们使用多继承语法来实现Minxin

  • 使用Mixin实现多继承的时候非常小心

    • 首先他必须表示某一单一功能，而不是某个物品
    • 职责必须单一，如果由多个功能，则写多个Mixin
    • Mixin不能依赖于子类的实现
    • 子类及时没有继承这个Mixin类， 也能照样工作，只是缺少了某个功能

  • 优点

    • 使用Mixin可以在不对类进行任何修改的情况下，扩充功能
    • 可以方便的组织和维护不同功能组件的划分
    • 可以根据需要任意调整功能类的组合
    • 可以避免创建很多新的类，导致类的继承混乱

  • 使用mixin的场景

    • 你希望给一个类提供很多特征的时候
    • 你希望很多不同的类使用一个相同的特征的时候

  • 案例

          # Mixin案例
      class Person():
                      name = "liuying"
                      age = 18

                      def eat(self):
                          print("EAT.......")

                      def drink(self):
                          print("DRINK......")

                      def sleep(self):
                          print("SLEEP.....")

      class Teacher(Person):
                      def work(self):
                          print("Work")

      class Student(Person):
                      def study(self):
                          print("Study")


      class Tutor(Teacher, Student):
                      pass

      t = Tutor()

      print(Tutor.__mro__)
      print(t.__dict__)
      print(Tutor.__dict__)

      print("*"*20)
      class TeacherMixin():
                      def work(self):
                          print("Work")

      class StudentMixin():
                      def study(self):
                          print("Study")

      class TutorM(Person, TeacherMixin, StudentMixin):
                      pass

      tt = TutorM()
      print(TutorM.__mro__)
      print(tt.__dict__)
      print(TutorM.__dict__)
      >>>
      (<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)
      {}
      {'__module__': '__main__', '__doc__': None}
      ********************
      (<class '__main__.TutorM'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
      {}
      {'__module__': '__main__', '__doc__': None}
posted @ 2020-02-18 10:44  声凉冫  阅读(109)  评论(0)    收藏  举报