面向对象 - 组合与封装

一、组合

组合指的是一个对象中,包含另一个或多个对象,组合可以减少代码冗余,提高程序的可扩展性

如何使用组合?

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

#学生类
class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        
#日期类
class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
    def tell_birth(self):
        print(f'''
        ===== 出生年月日 =====
            年: {self.year}
            月: {self.month}
            日: {self.day}
        ''')

stu1 = Student('baohan',18,'male')
date_obj = Date(2001,6,23)

#学生对象中包含一个自定义日期对象
stu1.date_obj = date_obj
# print(stu1.date_obj.year, stu1.date_obj.month, stu1.date_obj.day)
stu1.date_obj.tell_birth()
练习需求:
    选课系统:
        1.有学生、老师类,学生与老师有属性 “名字、年龄、性别、课程列表”,
        2.方法: 老师与学生可以添加课程, 打印学习/教授课程。

        3.课程对象:
            - 属性:
                - 课程名字
                - 课程价格
                - 课程周期

            - 方法:
                - 打印当前课程信息
                - 
# 组合实现
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    #添加课程
    def add_course(self,course_obj):   #self --->stu1
        self.course_list.append(course_obj)  #self --->stu1   [python_obj,go_obj

    #打印当前对象中课程列表的所有课程信息
    # --->打印所有课程
    def tell_all_course_info(self):  #self --->stu1
        #从当前对象中课程列表中取出所有的课程对象
        # self.course_list == [python_obj, go_obj]
        for course_obj in self.course_list:   

            # 1.course_obj ---> python_obj
            # 2.course_obj ---> go_obj

        	#通过课程对象,打印课程信息方法
        	# python_obj.tell_course_info(), go_obj.tell_course_info()
            course_obj.tell_course_info() 

class Teacher(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        #为当前对象添加课程列表属性 ---> []
        self.course_list = []

class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        #为当前对象添加课程列表属性 ---> []
        self.course_list = []

#定义一个课程类,课程有:课程名称,课程价格,课程周期
class Course:
    def __init__(self,course_name,course_price,course_time):
        self.course_name = course_name
        self.course_price = course_price
        self.course_time = course_time

    #定义打印课程方法:只打印当前课程信息
    def tell_course_info(self):
        print(f'''
        ======课程信息======
        课程名称:{self.course_name}
        课程价格:{self.course_price}
        课程周期:{self.course_time}
        ''')

#学生对象   属性: name,age,sex,course_list 方法: add_course,tell_all_course_info
stu1 = Student('baohan',18,'male')

#课程对象;属性: course_name,course_price,course_time 方法: tell_course_info
python_obj = Course('python',20000,6)
go_obj =Course('go',28888,8)

#学生对象调用父类的添加课程功能
stu1.add_course(python_obj)
stu1.add_course(go_obj)

# 学生调用打印 学生课程列表中所有课程的信息
stu1.tell_all_course_info()

总结:

  • 继承:是类与类的关系,子类继承父类的属性/方法,子类与父类是一种“从属”的关系
  • 组合:组合是对象与对象的关系,一个对象包含另一个或多个对象

二、封装

2.1 什么是封装

封:比如将一个袋子,封起来。
装:比如将一堆东西装在袋子里。

封装指的是可以将一堆属性和方法,封装到对象中。

ps:

  • 对象就好比一个“袋子/容器”,可以存放一堆属性和方法
  • 存不是目的,存的目的是为了取,可以通过"对象."的方式获取属性或方法

2.2 为什么要封装?

封装不是单纯意义的隐藏
1:封装数据:主要原因是:保护私隐,明确区分内外。将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制。
2:封装方法:目的是隔离复杂度

封装方法举例:

  1. 电视机本身是一个黑盒子,隐藏了所有细节,但是一定会对外提供了一堆按钮,这些按钮也正是接口的概念,所以说,封装并不是单纯意义的隐藏!!!

  2. 快门就是傻瓜相机为傻瓜们提供的方法,该方法将内部复杂的照相功能都隐藏起来了

提示:在编程语言里,对外提供的接口(接口可理解为了一个入口),可以是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体。

三、访问限制机制

3.1 什么是访问限制机制?

凡是在类内部定义的以__开头的属性或方法名,都会被限制,外部不能“直接访问”该原型。需要注意的是,这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形,主要用来限制外部的直接访问。

注意:凡是在类内部定义 __方法的属性和方法,都会变形为_类名__属性/方法

3.2 为什么要有访问限制机制?

可以将一些隐私的数据隐藏起来,不让外部轻易获取(设置成私有的)。

接口:可以将一对数据封装成一个接口,可以让用户调用接口,并且通过相应的逻辑,最后再将数据返回给用户。

3.3 如何实现访问限制机制?

其实这仅仅这只是一种变形操作,且仅仅只在类定义阶段发生变形

类中所有双下划线开头的名称如__x都会在类定义时自动变形成:_类名__x的形式:

class User:

	#__开头的属性
	__name = 'tank'  #__name 变形为 ---> _类名__name
	
	#__开头的方法
	def __run(self):
	print('tank is runing...')

#print(User.__name)  #报错
obj = User()
print(obj._User__name)

在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的,如下:

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> obj = B()
>>> obj.test()  # b.test --- >B---->A----> b.fa()----> b 是 B 的对象,在 B 里找 fa
from B
 

#把fa定义成私有的,即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa()# 在定义的时候就变形了,self.__fa() 变成:self._A__fa()
... 
>>> class B(A):
...     def __fa(self):  # _B__fa
...         print('from B')
... 
>>> b=B()
>>> b.test() # b.test --- >B没有---->找A的test----> b.fa()----> b._A__fa  找的A的 __fa
from A 
例:
class User:
    # 开头的属性
    __name = 'tank'    # __name变形为 ---》 _类名__name
    __age = 17
    __sex = 'male'

    # 校验接口,获取用户信息
    def par_user(self, username, password):
        if username == 'tank' and password == '123':
                print(f'''
                通过验证,获取用户信息。
                用户名: {self.__name}
                用户年龄: {self.__age}
                用户性别: {self.__sex}
                ''')
        else:
            print('校验失败,无法查询用户信息')

    #__开头的方法
    def __run(self):
        print('tank is running..')

obj = User()
obj.par_user('tank','123')

四、property

4.1、什么是property?

是一个python内置的装饰器,可以装饰在类内部的方法上。
可以将该方法 ----> 对象.方法() ----> 对象.方法

4.2 为什么要用property?

ps:
1.在某些场景下,调用的方法只是用来获取计算后的某个值。
2.目的是为了迷惑调用者把调用的方法误以为是属性。

4.3 如何使用?

class User:
    def __init__(self,name,weight,height):
        self.__name = name
        self.weight = weight
        self.height = height

    #获取BMI指数的方法
    @property
    def bmi(self):
        return self.weight/(self.height**2)

user_obj = User('baohan',50,1.67)
#user_obj.bmi 此时就不用加括号了,让别人看起来就像执行了属性一样
print(user_obj.bmi)
# 需求: 计算人体 bmi 指数
# 体重 / 身高的平方

class User:
    def __init__(self,name,weight,height):
        self.__name = name
        self.weight = weight
        self.height = height

    #获取BMI指数的方法
    @property
    def bmi(self):
        return self.weight/(self.height**2)

    #了解:设置被property装饰后的方法
    @property
    def name(self):
        return self.__name

    #注意:需要修改的方法名字要与被property装饰器后的方法一样
    @name.setter
    def name(self,value):
        self.__name = value
user_obj = User('baohan',50,1.67)
#user_obj.bmi 此时就不用加括号了,让别人看起来就像执行了属性一样
print(user_obj.name)

user_obj.name ='gaogao'
print(user_obj.name)
# 需求: 计算人体 bmi 指数
# 体重 / 身高的平方

class User:
    def __init__(self,name,weight,height):
        self.__name = name
        self.weight = weight
        self.height = height

    #获取BMI指数的方法
    @property
    def bmi(self):
        return self.weight/(self.height**2)

    #了解:设置被property装饰后的方法
    @property
    def name(self):
        return self.__name

    #注意:需要修改的方法名字要与被property装饰器后的方法一样
    @name.setter
    def name(self,value):
        self.__name = value

    @name.deleter
    def name(self):  #删除属性
        del self.__name

user_obj = User('baohan',50,1.67)

del user_obj.name

posted @ 2020-01-03 08:27  Hank·Paul  阅读(218)  评论(0编辑  收藏  举报