Python学习day25-面向对象之组合,多态和封装
组合
组合,简单来说就是对象的某个属性是另一个类的对象,有点类似于嵌套的意思,但是不全一样。使用组合最大的优点还是可以减少代码的冗余。举一个最简单的组合的例子:
xxxxxxxxxx
8
1
class Foo:
2
def __init__(self,bar):
3
self.bar = bar
4
class Bar:
5
pass
6
f = Foo()
7
f.bar = Bar()
8
f = Foo(Bar())
上述例子中,类中的Foo的内置属性中就有Bar类,所以是组合的一种体现。
再来看一个稍微复杂一点的例子:
需求,我们需要一个老师类,一个学生类,学生类包括姓名,年龄,所选课程,
老师类包括姓名,年龄,所教课程。
运用组合的方法实现如下:
xxxxxxxxxx
59
1
# 定义一个人基类,老师类和学生类都从此继承出来
2
class Person:
3
school = 'oldboy'
4
5
def __init__(self, name, age):
6
self.name = name
7
self.age = age
8
9
# 定义老师类,包括姓名,年龄,所教课程
10
class Teacher(Person):
11
def __init__(self, name, age, course):
12
super().__init__(name, age)
13
self.course_list = course
14
# course是课程对象,是老师教授的课程
15
# 定义课程对象,课程包括名字,价格,时间周期
16
class Course:
17
def __init__(self, c_name, c_price, c_period):
18
self.name = c_name
19
self.price = c_price
20
self.period = c_period
21
# 定义学生类,继承于人基类,且和课程类有所组合
22
class Student(Person):
23
# course = list()#课程的列表不能放在这里,因为每次实例化都会清零,所以这是错误放法
24
25
def __init__(self, name, age):
26
super().__init__(name, age)
27
self.course_list = list()# 课程列表应该放在这里,也就是实例化时候默认加载的地方,init里面
28
29
# course是课程对象,是学生选择的课程
30
def choose_course(self, course):
31
# self.course = list()#课程同样不能放在这里,因为每次学生调用选课方法的话课程列表就会清零,错误放法
32
self.course_list.append(course)
33
34
# 定义一个学生查看自己所选课程的方法
35
def tell_all_course(self):
36
# 循环学生选课列表,每次拿出一个课程对象
37
for course in self.course_list:
38
print(course.name)
39
40
# 实例化产生一个课程对象
41
course = Course('Python', 20180, 7)
42
# 实例化产生一个学生对象
43
stu1 = Student('nick', 19)
44
# 学生对象调用选课方法,选择上面产生的课程对象
45
stu1.choose_course(course)
46
47
48
stu2 = Student('www', 19)
49
stu2.choose_course(course)
50
stu2.choose_course(Course('linux', 19999, 5))
51
stu2.tell_all_course()
52
53
# print(stu1.__dict__)
54
# print(stu2.__dict__)
55
56
# teacher = Teacher('tank', 19, '高级', course)
57
# 查看老师教授的课程名
58
# print(teacher.course.name)
59
# 这种连续调用的方法会极大的减少代码量,也会使整个的项目变得简练,逻辑清楚,即每个对象都是一个百宝箱。
多态与多态性
多态,顾名思义,多种形态,即一类事物的多种形态。
比如现实生活中,动物类,包括猪,狗,猫,长颈鹿,老虎等等,就是同一类事物的多重形态,当然我们还可以继续往下分类,这个问题在这里不是关键。
而多态性就是指在不考虑实例类型的情况下使用实例。
我们用最简单的实例来实现一下多态的概念。
xxxxxxxxxx
31
1
class Animal:
2
def speak(self):
3
pass
4
5
6
class Pig(Animal):
7
def speak(self):
8
print('哼哼哼')
9
10
11
class Dog(Animal):
12
def speak(self):
13
print('汪')
14
15
16
class People(Animal):
17
def speak(self):
18
print('hello')
19
20
21
pig = Pig()
22
dog = Dog()
23
people = People()
24
pig.speak()
25
dog.speak()
26
people.speak()
27
def animal_speak(obj):
28
obj.speak()
29
animal_speak(pig)
30
31
# 这个实例的意思大概就是,每个动物都能发出自己的声音,那么我们给每个动物定义一个类,以及同样的speak方法,那么我们就可以通过定义另外一个调用自身speak方法的函数来实现动物发出声音这个功能,只需要在animal_speak后面加上需要发声的动物就行了。
所以其实这种调用方式有一个问题,就是如果定义别的动物类的时候其内部没有speak这个方法,那么就会报错,所以我们就要想办法去约束这个事情,官方的话就是我们要约束子类的共有特性。
常用的约束方法有两种:
-
一个是用abc实现接口的统一化,abc和装饰器的用法有些类似,需要在前面加@
xxxxxxxxxx
1371import abc
2class Animal(metaclass=abc.ABCMeta):
3abstractclassmethod .
4def speak(self): # 规定了我的子类必须有这个方法,如果没有,调用就没有输出,就不能利用多态性,做约束作用
5pass
6
7
8class Pig(Animal):
9abstractclassmethod .
10def speak(self):
11print('哼哼哼')
12
13
14class Dog(Animal):
15abstractclassmethod .
16def zz(self):
17print('汪')
18
19
20class People(Animal):
21abstractclassmethod .
22def cc(self):
23print('hello')
24
25
26pig = Pig()
27dog = Dog()
28people = People()
29pig.speak()
30dog.speak()
31people.speak()
32
33
34def animal_speak(obj):
35obj.speak()
36
37
38animal_speak(pig)
-
第二个就是比较常用的方式,就是用异常处理来约束子类
xxxxxxxxxx
1111191class Animal():
2def speak(self):
3# 主动抛出异常
4raise Exception('需要重写')
5
6
7class Pig(Animal):
8def speak(self):
9print('哼哼哼')
10
11
12pig = Pig()
13
14
15def animal_speak(obj):
16obj.speak()
17
18
19animal_speak(pig)
20# 这种情况下,如果子类里面没有父类的方法,那么调用时候就会主动抛出异常,通知你需要重写这些方法。
- 说起来是有这两种约束子类的方法,但实际上,Python是一种十分崇尚鸭子类型的语言,鸭子类型就是说,只要你走起路来像鸭子,那么你就是鸭子。换做在Python里就是说,只要你能实现这些功能,我们不太关心你是怎么实现的,用了什么方法或者变量,所以一般Python做的一些比较大的项目,并不会去约束你的子类方法是如何写的,而只是靠程序员自己来把控,自由度非常高。
封装
封装的字面意思就是把一堆东西放在袋子里,然后封上口。但是如果封装==隐藏的话,就太片面了。
封装只是在于明确其使用范围,封装的属性或者方法,都可以在类内部直接使用,但是不能被外部直接使用,我们需要另外写一些函数或者方法,来让外部以我们想让他们看到的方式看到这些隐藏的内容。
我们先来看一下如何去把类里面的属性或方法设置成隐藏:
xxxxxxxxxx
1
18
1
# 隐藏属性:主要目的是为了保护原有数据,不让别人修改
2
# 把name隐藏起来
3
class Person:
4
def __init__(self, name, age):
5
self.__name = name# 在需要隐藏的属性前面加上__就可以将其设置成隐藏属性,也就是封装
6
self.age = age
7
8
def get_name(self): # 可以另外增加一些功能,或者不同的打印方式
9
return self.__name
10
11
12
p = Person('nick', 18)
13
14
print(p.age)
15
# print(p.__name)
16
print(p.get_name())
17
# Python中隐藏的属性就真的访问不到了么,并不是的
18
# 实际上隐藏的属性还是可以访问到
19
print(p.__dict__)# 我们先查看对象的字典属性,里面会写真正的被隐藏变量的名字
20
print(p._Person__name)# 直接用我们看到的异常属性名字就可以直接看到隐藏变量
21
# 不过非常不推荐这种做法,毕竟隐藏属性就是为了隐藏起来,你非要去把人家调出来干嘛。。。
xxxxxxxxxx
1
14
1
# 隐藏方法:主要目的是隔离复杂度,使用者不用考虑有多少种方法,只需要调用那个对外的方法就可以了,毕竟里面的方法你也看不到
2
class Person:
3
def __init__(self, name, age):
4
self.__name = name
5
self.age = age
6
7
def __speak(self): # 通过封装方法,让方法只在内部使用,对外只提供一个接口就可以
8
print('666')
9
10
11
p = Person('nick', 89)
12
# p._Person__speak()
13
print(Person.__dict__)
14