面向对象（三）——组合、多态、封装、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','')
 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伪装成数据属性

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

property拓展