面向对象 - 组合与封装
一、组合
组合指的是一个对象中,包含另一个或多个对象,组合可以减少代码冗余,提高程序的可扩展性
如何使用组合?
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:封装方法:目的是隔离复杂度
封装方法举例:
-
电视机本身是一个黑盒子,隐藏了所有细节,但是一定会对外提供了一堆按钮,这些按钮也正是接口的概念,所以说,封装并不是单纯意义的隐藏!!!
-
快门就是傻瓜相机为傻瓜们提供的方法,该方法将内部复杂的照相功能都隐藏起来了
提示:在编程语言里,对外提供的接口(接口可理解为了一个入口),可以是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体。
三、访问限制机制
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