Python学习day25-面向对象之组合,多态和封装
组合
组合,简单来说就是对象的某个属性是另一个类的对象,有点类似于嵌套的意思,但是不全一样。使用组合最大的优点还是可以减少代码的冗余。举一个最简单的组合的例子:
xxxxxxxxxx
class Foo:
def __init__(self,bar):
self.bar = bar
class Bar:
pass
f = Foo()
f.bar = Bar()
f = Foo(Bar())
上述例子中,类中的Foo的内置属性中就有Bar类,所以是组合的一种体现。
再来看一个稍微复杂一点的例子:
需求,我们需要一个老师类,一个学生类,学生类包括姓名,年龄,所选课程,
老师类包括姓名,年龄,所教课程。
运用组合的方法实现如下:
xxxxxxxxxx
# 定义一个人基类,老师类和学生类都从此继承出来
class Person:
school = 'oldboy'
def __init__(self, name, age):
self.name = name
self.age = age
# 定义老师类,包括姓名,年龄,所教课程
class Teacher(Person):
def __init__(self, name, age, course):
super().__init__(name, age)
self.course_list = course
# course是课程对象,是老师教授的课程
# 定义课程对象,课程包括名字,价格,时间周期
class Course:
def __init__(self, c_name, c_price, c_period):
self.name = c_name
self.price = c_price
self.period = c_period
# 定义学生类,继承于人基类,且和课程类有所组合
class Student(Person):
# course = list()#课程的列表不能放在这里,因为每次实例化都会清零,所以这是错误放法
def __init__(self, name, age):
super().__init__(name, age)
self.course_list = list()# 课程列表应该放在这里,也就是实例化时候默认加载的地方,init里面
# course是课程对象,是学生选择的课程
def choose_course(self, course):
# self.course = list()#课程同样不能放在这里,因为每次学生调用选课方法的话课程列表就会清零,错误放法
self.course_list.append(course)
# 定义一个学生查看自己所选课程的方法
def tell_all_course(self):
# 循环学生选课列表,每次拿出一个课程对象
for course in self.course_list:
print(course.name)
# 实例化产生一个课程对象
course = Course('Python', 20180, 7)
# 实例化产生一个学生对象
stu1 = Student('nick', 19)
# 学生对象调用选课方法,选择上面产生的课程对象
stu1.choose_course(course)
stu2 = Student('www', 19)
stu2.choose_course(course)
stu2.choose_course(Course('linux', 19999, 5))
stu2.tell_all_course()
# print(stu1.__dict__)
# print(stu2.__dict__)
# teacher = Teacher('tank', 19, '高级', course)
# 查看老师教授的课程名
# print(teacher.course.name)
# 这种连续调用的方法会极大的减少代码量,也会使整个的项目变得简练,逻辑清楚,即每个对象都是一个百宝箱。
多态与多态性
多态,顾名思义,多种形态,即一类事物的多种形态。
比如现实生活中,动物类,包括猪,狗,猫,长颈鹿,老虎等等,就是同一类事物的多重形态,当然我们还可以继续往下分类,这个问题在这里不是关键。
而多态性就是指在不考虑实例类型的情况下使用实例。
我们用最简单的实例来实现一下多态的概念。
xxxxxxxxxx
class Animal:
def speak(self):
pass
class Pig(Animal):
def speak(self):
print('哼哼哼')
class Dog(Animal):
def speak(self):
print('汪')
class People(Animal):
def speak(self):
print('hello')
pig = Pig()
dog = Dog()
people = People()
pig.speak()
dog.speak()
people.speak()
def animal_speak(obj):
obj.speak()
animal_speak(pig)
# 这个实例的意思大概就是,每个动物都能发出自己的声音,那么我们给每个动物定义一个类,以及同样的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
# 隐藏属性:主要目的是为了保护原有数据,不让别人修改
# 把name隐藏起来
class Person:
def __init__(self, name, age):
self.__name = name# 在需要隐藏的属性前面加上__就可以将其设置成隐藏属性,也就是封装
self.age = age
def get_name(self): # 可以另外增加一些功能,或者不同的打印方式
return self.__name
p = Person('nick', 18)
print(p.age)
# print(p.__name)
print(p.get_name())
# Python中隐藏的属性就真的访问不到了么,并不是的
# 实际上隐藏的属性还是可以访问到
print(p.__dict__)# 我们先查看对象的字典属性,里面会写真正的被隐藏变量的名字
print(p._Person__name)# 直接用我们看到的异常属性名字就可以直接看到隐藏变量
# 不过非常不推荐这种做法,毕竟隐藏属性就是为了隐藏起来,你非要去把人家调出来干嘛。。。
xxxxxxxxxx
# 隐藏方法:主要目的是隔离复杂度,使用者不用考虑有多少种方法,只需要调用那个对外的方法就可以了,毕竟里面的方法你也看不到
class Person:
def __init__(self, name, age):
self.__name = name
self.age = age
def __speak(self): # 通过封装方法,让方法只在内部使用,对外只提供一个接口就可以
print('666')
p = Person('nick', 89)
# p._Person__speak()
print(Person.__dict__)