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

2023-08-26 17:00:22

组合、多态、封装、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拓展

码农公寓