面向对象（三）——组合、多态、封装、property装饰器

组合、多态、封装、property装饰器

一、组合

1、什么是组合

组合指的是某一个对象拥有一个属性，该属性的值是另外一个类的对象

class Foo():
    pass

class Bar():
    pass

obj=Bar()
obj.attrib=Foo()

2、组合的作用

通过为某一个对象添加属性(属性值是另外一个类的对象)的方式,可以间接地将两个类关联/整合/组合到一起，从而减少类与类之间代码冗余

3、组合的使用

class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


class OldboyStudent(OldboyPeople):

    def __init__(self, name, age, sex, score=0):
        super().__init__(name, age, sex)
        self.score = score
        self.courses = []

    def choose_course(self):
        print('%s choosing course' % self.name)

    def tell_all_course(self):
        print(('学生[%s]的课程如下' % self.name).center(60, '='))
        for course in self.courses:
            course.tell_course()
        print('=' * 80)


class OldboyTeacher(OldboyPeople):

    def __init__(self, name, age, sex, level):
        super().__init__(name, age, sex)
        self.level = level
        self.courses = []

    def score(self, stu, num):
        stu.score = num

    def tell_all_course(self):
        print(('老师[%s]教授的课程如下' % self.name).center(70, '-'))
        for course in self.courses:
            course.tell_course()
        print('-' * 80)


class Course:
    def __init__(self, c_name, c_price, c_period):
        self.c_name = c_name
        self.c_price = c_price
        self.c_period = c_period

    def tell_course(self):
        print('<课程名：%s 价格：%s 时间：%s>' % (self.c_name, self.c_price, self.c_period))


python = Course('python全栈开发', 10000, 5)
linux = Course('linux架构', 12000, 5)

stu = OldboyStudent('zs', 18, 'male')
stu.courses.append(python)
stu.courses.append(linux)
stu.tell_all_course()

teach = OldboyTeacher('egon', 18, 'male', 10)
teach.courses.append(python)
teach.tell_all_course()

二、多态与多态性

1、什么是多态

多态指的是同一种/类事物的不同形态

class Animal:
    def speak(self):
        pass

class People(Animal):
    def speak(self):
        print('say hello')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

class Pig(Animal):
    def speak(self):
        print('哼哼哼')

2、抽象类

只是用来建立规范的,不能用来实例化的,更无需实现内部的方法

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

    @abc.abstractmethod
    def run(self):
        pass

class People(Animal):
    def speak(self):
        print('say hello')

    def run(self):
        pass

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

    def run(self):
        pass

class Pig(Animal):
    def speak(self):
        print('哼哼哼')

    def run(self):
        pass

obj1=People()
obj2=Dog()
obj3=Pig()

三、封装

1、什么是封装

装:往容器/名称空间里存入名字
封:代表将存放于名称空间中的名字给藏起来,这种隐藏对外不对内

2、怎么封装

（1）在类内定义的属性前加__开头(没有__结果)

（2）__开头的属性实现的隐藏仅仅只是一种语法意义上的变形，并不会真的限制类外部的访问，外部可以调用类内的接口来操作属性

（3）该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形

class Foo:
    __x=111         # _Foo__x    在定义的时候已经将__x改为_Foo__x
    __y=222         # _Foo__y    在定义的时候就将__y改成_Foo__y

    def __init__(self,name,age):
        self.__name=name     # 函数再定义的时候添加属性，可以被封装
        self.__age=age

    def __func(self):     # 在定义的时候已经将__func改为_Foo__func
        print('func')

    def get_info(self):
        print(self.__name,self.__age,self.__x)  # 内部可以访问封装的属性

print(self._Foo__name,self._Foo__age,self._Foo__x)

print(Foo.__x)     # 报错  无法直接访问封装的属性

print(Foo.__dict__)

print(Foo._Foo__x)    # 111 封装只是在属性前面加了“_类名”，可以访问封装的属性

Foo.__z=333

print(Foo.__z)    # 333 后期添加的属性不会被封装，封装只发生在类定义的阶段

3、封装数据属性

（1）将数据属性隐藏起来，类外就无法直接操作属性

（2）需要类内开辟一个接口来外部的使用可以间接地操作属性，可以在接口内定义任意的控制逻辑，从而严格控制使用对属性的操作

class People:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def tell_info(self):   #接口用来访问封装的数据属性
        print('<name:%s age:%s>'  %(self.__name,self.__age))

    def set_info(self,name,age):  # 接口用来修改封装的数据属性的值
        if type(name) is not str:
            print('名字必须是str类型')
            return
        if type(age) is not int:
            print('年龄必须是int类型')
            return
        self.__name=name
        self.__age=age


obj=People('egon',18)
# obj.tell_info()

# obj.set_info('EGON',19)
# obj.set_info(123,19)
obj.set_info('EGON','18')
obj.tell_info()

4、封装函数属性

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

四、property装饰器

property装饰器是用来将类内的函数属性伪装成数据属性

class People:
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height

    @property       # property装饰器
    def bmi(self):
        return self.weight / (self.height ** 2)


obj = People(70, 1.75)

print(obj.bmi)   # bmi被property伪装成数据属性

class People:
    def __init__(self,name):
        self.__name=name

    @property
    def name(self):
        return '<名字:%s>' %self.__name

    @name.setter
    def name(self,obj):
        if type(obj) is not str:
            print('name必须为str类型')
            return
        self.__name=obj

    @name.deleter
    def name(self):
        # print('不让删')
        del self.__name

obj=People('egon')

print(obj.name)        # egon
obj.name='EGON'
#obj.name=123
print(obj.name)    # EGON