组合与重用性，抽象类

组合与继承

1.继承的方式

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

2.组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

示例：继承与组合

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

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Teacher(People):
    def __init__(self,name,age,sex,job_title):
        super().__init__(name,age,sex)
        self.job_title=job_title
        self.course = []
        self.students =[]

    def tell_info(self):
        for c in self.students:
            print('%s 教学生 %s'%(self.name,c.name))
        for s in self.course:
            print('%s 教课程 %s'%(self.name,s.name))


class Student(People):
    def __init__(self,name,age,sex):
        super().__init__(name,age,sex)
        self.course=[]


egon=Teacher('egon',18,'male','金牌讲师')
s1=Student('s1',18,'female')

python=Course('python','3mons',3000.0)
linux=Course('linux','4mons',5000.0)

#为老师egon和学生s1添加课程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)

#为老师egon添加学生s1
egon.students.append(s1)

egon.tell_info()

#使用
for item in egon.course:
   item.tell_info()

# egon 教学生 s1
# egon 教课程 python
# egon 教课程 linux
# <python 3mons 3000.0>
# <linux 4mons 5000.0>

总结：

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

抽象类

什么是抽象类

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

　比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

　从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案

在python中实现抽象类

import abc
class Animal(metaclass=abc.ABCMeta):#只能被继承，不能被实例化

    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass




class Pig(Animal): #子类继承抽象类，但是必须定义run和eat方法
    
    def run(self):
        print('pig is walking')

    def eat(self):
        print('pig is eating')


class Dog(Animal):#子类继承抽象类，但是必须定义run和eat方法
    def run(self):
        print('dog is walking')

    def eat(self):
        print('dog is eating')

dog = Dog()
dog.run()
dog.eat()

pig = Pig()
pig.run()
pig.eat()

# dog is walking
# dog is eating
# pig is walking
# pig is eating

抽象类与接口

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如eat、run），而接口只强调函数属性的相似性。