面向对象：组合、抽象类

组合：适用于“什么有什么”；组合方法：类1对象.变量=类2对象

选课例题：

classLuffyPeople:
school="luffycity"

def__init__(self,name,gender,age):
self.name=name
self.gender=gender
self.age=age

classTeacher(LuffyPeople):

def__init__(self,name,gender,age,level,salary):
super().__init__(name,gender,age)

self.level=level
self.salary=salary

defteach(self):
print("%sisteaching"%self.name)

classStudent(LuffyPeople):

def__init__(self,name,gender,age,class_time):
super().__init__(name,gender,age)

self.class_time=class_time

deflearn(self):
print("%sislearning"%self.name)

classCourse:

def__init__(self,course_name,course_price,course_period):
self.course_name=course_name
self.course_price=course_price
self.course_period=course_period

"""生成两个teacher对象"""
teacher1=Teacher("alex","male",22,10,3000)
teacher2=Teacher("egon","male",28,20,5000)

"""生成一个课程对象"""
python=Course("Python",6000,"3mons")

"""
老师对象和课程对象之间：不是“什么是什么”的关系，所以不能用类的继承；
而是老师“有”课程的关系，所以应该是给老师这个对象添加一个课程的属性
"""
teacher1.course=python#teacher1.course是一个课程对象
teacher2.course=python#通过.course(变量)把teacher1和python这两个变量整合在了一起

print(python)
print(teacher1.course)
print(teacher2.course)
#打印结果：
#<__main__.Courseobjectat0x000000E943066C18>
#<__main__.Courseobjectat0x0000009FB7406C18>
#<__main__.Courseobjectat0x0000009FB7406C18>

"""查看teacher教的课程名"""
print(teacher1.course.course_name)#teacher1.course.course_name就相当于python.course_name#给老师这个对象定制了一个课程的属性

#打印结果：
#Python

"""生成一个学生对象"""
stu1=Student("neo","male",22,"08:30:00")

为了方便查询课程信息，可以在Course这个类中专门添加一个查询课程信息的功能（函数），如下所示：

classCourse:

def__init__(self,course_name,course_price,course_period):
self.course_name=course_name
self.course_price=course_price
self.course_period=course_period

"""为了方便查询课程信息，可以定义一个课程查询的函数"""
deftell_info(self):
print("课程名<%s>课程价格<%s>课程周期<%s>"%(self.course_name,self.course_price,self.course_period))

"""查询teacher1的课程信息"""
teacher1.course.tell_info()

#运行结果：
#课程名<Python>课程价格<6000>课程周期<3mons>

给老师teacher1这个对象定制了一个课程的属性（变量course），然后让这个课程属性（变量course）指向了另外一个课程对象python，通过这种方式让teacher1“有了”python；这种“什么有什么”的方式就是“组合”，把Course类和Teacher类“组合”在了一起。通过“组合”，能够让好多类组合在一起

如：

"""生成两个课程对象"""
python=Course("Python",6000,"3mons")
linux=Course("Linux",4000,"5mons")

"""生成一个学生对象"""
stu1=Student("neo","male",22,"08:30:00")

"""给stu1添加python和linux两门课程"""
stu1.course1=python
stu1.course2=linux

stu1.course1.tell_info()
stu1.course2.tell_info()

#运行结果：
#课程名<Python>课程价格<6000>课程周期<3mons>
#课程名<Linux>课程价格<4000>课程周期<5mons>

#也可以用列表的形式添加课程对象
stu1.course=[]
stu1.course.append(python)
stu1.course.append(linux)

print(stu1.course)

#运行结果：
#[<__main__.Courseobjectat0x0000002E85B36C88>,<__main__.Courseobjectat0x0000002E85B36CC0>]

抽象类：

示例代码如下：

importabc#导入abc模块

"""抽象类的定义方法"""
classAnimal(metaclass=abc.ABCMeta):#抽象类的括号里面要传入metaclass=abc.ABCMeta
all_type="animal"#抽象类也是类的一种，其内部的功能属性也能够被其子类调用

@abc.abstractmethod
defrun(self):
pass

@abc.abstractmethod
defeat(self):
pass
"""
装饰器：@abc.abstractmethod
定义函数
pass（即不写具体的执行代码）
"""
"""
这种功能名（函数）在Animal的子类中一定要有，否则子类不能被实例化
所以通过抽象类的方式，能够统一功能名
"""

classPeople(Animal):

defrun(self):
print("peopleisrunning")

defeat(self):
pass

people=People()#因为People这个类中有run和eat这两个功能，所以能够实例化
print(people.all_type)

#运行结果：
#animal

"""另外，抽象类只能被继承，不能被实例化"""