静态，组合，继承

class vihecle:
    def __init__(self,name,speed,load):
        self.name=name
        self.speed=speed
        self.load=load
    def show_info(self):
        print("开动啦")
class b(vihecle):
    def __init__(self,name,speed,load,line):
        super().__init__(name,speed,load)#调用了父类的方法，self自动传递了，调用父类的方法使用supper（）
        self.line=line

    def show_info(self):
        super().show_info()
        print("我是来自子类的")
b1=b("北京地铁","1000km/s",10000,13)
b1.show_info()

class school:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao(self):
         print("学校正在招生")
class course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.p=price
        self.pp=period
        self.school=school
s1=school("oldbay","beijing")
s2=school("oldbay","lanjing")
s3=school("oldbay","gansu")
c1=course("linux",10,"1h",s1)
print(c1.__dict__)
print(c1.school.name)#类的组合

class school:
    x=1
    def __init__(self,name,add,type):
        self.name=name
        self.add=add
        self.type=type
    def tell_info(self):
        print("学校的详细介绍")
s=school("清华","北京","公立")
print(s.__dict__)
print(school.__dict__)
s.tell_info()#实例调用类方法的时候python自动传进了一个参数，但是类不行
school.tell_info(s)#这儿必须自己传参数，因为是类调用类方法，所以不会自动传进参数。

 类的组合用来类和类之间的关联，将小类做成大类。两个类之间没有共同点，但是类和类之间有关联，这就用类的组合来实现。

   组合的定义

　　代码重用的重要方式除了继承之外还有另外一种方式，即：组合

　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。

     

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name 
        self.gender=gender
        self.birth=birth
        self.course=course
    def teach(self): 
        print('teaching')

p1=Teacher('egon','male', 
            BirthDate('1995','1','27'), 
            Couse('python','28000','4 months')
           ) 

print(p1.birth.year,p1.birth.month,p1.birth.day) 

print(p1.course.name,p1.course.price,p1.course.period)
''' 
运行结果: 
27 
python 28000 4 months 
'''

继承同时含有两种含义：

含义一：继承基类的方法，并且做出自己的改变或者扩展（代码重用），意义不大。

含义二：申明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法。

接口中只是申明函数，但是不能实现函数，用来规范子类，只是所有继承接口的类必须实现接口中的方法。

import abc

必须给接口中的方法添加装饰器，@abc.abstractmethod.

在接口定义中加上参数methodclass=abc.ABCMeta

继承顺序：python中可以继承多各类，但是Java中只能继承一个类。

在python3中，继承的顺序是广度优先。（和数据结构中的广度优先是由区别的，不能混淆）

在python2中，继承的顺序有广度优先和深度优先。

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

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

class vihecle:
    def __init__(self,name,speed,load):
        self.name=name
        self.speed=speed
        self.load=load
    def show_info(self):
        print("开动啦")
class b(vihecle):
    def __init__(self,name,speed,load,line):
        super().__init__(name,speed,load)#调用了父类的方法，self自动传递了，调用父类的方法使用supper（）
        self.line=line

    def show_info(self):
        super().show_info()
        print("我是来自子类的")
b1=b("北京地铁","1000km/s",10000,13)
b1.show_info()

 多态：

不同对象调用相同的方法，产生不一样的结果，这就是多态。