python学习笔记——面向对象的三大特征：封装，继承，多态。

面向对象的三大特征

封装

继承

多态

1.封装

• 封装就是对对象的成员进行访问限制

封装的三个级别：

• 公开，public
• 受保护的，protected
• 私有的，private
• public，private，protected不是关键字

判别对象的位置

• 对象内部
• 对象外部
• 子类中

私有 private

• 私有成员是最高级别的封装，只能在当前类或对象中访问
• 在成员前面添加两个两个下划线即可

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

受保护的封装 protected

• python中所谓的“保护”指的是顶级对象相对于module的可见性
  受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都可以进行访问，但是在外部不可以,而Python中受“保护”的对象，跟java不太一样，如果是类(对象)的成员，其实相当于没保护，不管是不是夸包，都可以随意访问，而且继承也不受任何限制。如果被保护的是顶级的函数或变量，那就有用了，这些函数和变量不允许被import到其他包中。
• 封装方法： 在成员名称前添加一个下划线即可

公开的，公共的 public

• 公共的封装实际对成员没有任何操作，任何地方都可以访问

案例

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

# name是公有变量
print(p.name)
# __age是私有变量,直接访问报错
print(p.__age)
# name mangling技术
print(p._Person__age)    ## 私有变量实际改名为_Person__age

>liuying
>AttributeError: 'Person' object has no attribute '__age'
>18

2.继承

• 继承就是一个类可以获得另外一个类中的成员属性和成员方法
• 作用： 减少代码，增加代码的复用功能， 同时可以设置类与类直接的关系

继承与被继承的概念：

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

继承的特征

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

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

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

单继承和多继承

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

案例

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

class Person():
    name = "NoName"
    age = 80
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" # 小名，是保护的，子类可以用，但不能公用

    def sleep(self):
        print("Sleeping ... ...")
    def work(self):
        print('make some money')

# 父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    age = 18

    def make_test(self):
        print("attention")

    def work(self):
        # 扩充父类的功能只需要调用父类相应的函数
        # Person.work(self) # 扩充父类的另一种方法 # super代表得到父类  super().work()
        self.make_test()

t = Teacher()
print(t.name)
print(t.age)
print(t._petname)

t.sleep()
print(t.teacher_id)
t.make_test()
t.work()

>NoName
>18
>sec
>Sleeping ... ...
>9527
>attention
>make some money
>attention

多继承案例

# 多继承的例子
# 子类可以直接拥有父类的属性和方法，私有属性和方法除外

class Base(object):
    def test(self):
        print("------base")

class A(Base):
    def test1(self):
        print("------test1")

class B(Base):
    def test2(self):
        print("------test2")

class C(A, B):
    pass

c = C()
c.test1()
c.test2()
c.test()
>------test1
>------test2
>------base

继承中的构造函数

构造函数

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

super

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

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

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

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第二个被自动的调用(第一个为__new__) # 因为主要工作是进行初始化，所以得名
    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‘

********************************************************

# 构造函数的调用顺序
class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self, name):
        print("B")
        print(name)

class C(B):
    # c中想扩展B的构造函数，
 # 即调用B的构造函数后在添加一些功能 # 由两种方法实现
    '''
 # 第一种是通过父类名调用 
    def __init__(self, name): 
    # 首先调用父类构造函数 
    B.__init__(self, name) 
    # 其次，再增加自己的功能 
    print("这是C中附加的功能") 
    '''
  # 第二种，使用super调用
    def __init__(self, name):
        # 首先调用父类构造函数
    super(C, self).__init__(name)
        # 其次，再增加自己的功能
    print("这是C中附加的功能")

# 此时，首先查找C的构造函数
# 如果没有，则向上按照MRO顺序查找父类的构造函数，知道找到为止
# 此时，会出现参数结构不对应错误
c = C("我是C")

>B
>我是C
>这是C中附加的功能

3.多态

• 多态就是同一个对象在不同情况下有不同的状态出现
• 多态不是语法，是一种设计思想
• 多态性： 一种调用方式，不同的执行效果
• 多态： 同一事物的多种形态，动物分为人类，狗类，猪类
  多态和多态性

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

我们使用多继承语法来实现Minxin
使用Mixin实现多继承的时候非常小心

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

优点

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

案例

# 多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）
class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')

class People(Animal):
    def run(self):
        print('人正在走')

class Pig(Animal):
    def run(self):
        print('pig is walking')

class Dog(Animal):
    def run(self):
        print('dog is running')

peo1 = People()
pig1 = Pig()
d1 = Dog()

peo1.run()
pig1.run()
d1.run()
>人正在走
>pig is walking
>dog is running

Mixin

# 实例1
## 未使用Mixin
class Person():
    name = "liuying"
    age = 18
    def eat(self):
        print("EAT.......")

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__)
>(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)
>{}
>{'__module__': '__main__', '__doc__': None}
## 使用Mixin
class Person():
    name = "liuying"
    age = 18
    def eat(self):
        print("EAT.......")

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

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

class Tutor(Person, TeacherMixin, StudentMixin):
    pass

t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
>(<class '__main__.Tutor'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
>{}
>{'__module__': '__main__', '__doc__': None}