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设计模式

  • 主要采用多继承方式对类的功能进行扩展
  • Mixin概念
  • MRO and Mixin
  • Mixin模式
  • Mixin MRO
  • MRO

• 我们使用多继承语法来实现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}