Python全栈开发——类继承和组合

Posted 2021-01-09 IT_study

# 类组合
将几个不相关的类组合在一起
#什么时候用：当类之间有显著的不同，并且较小的类是较大的类所需组件时，用组合

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print(\'%s is \' %self.name)
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school_lujiacheng=school
s1=School(\'oldboy\',\'BeiJing\')

c1=Course(\'boydoy\',\'1000\',15,s1)   #建立关系
#访问
print(c1.school_lujiacheng.name)    #oldboy
print(c1.school_lujiacheng.addr)    #BeiJing

#继承
 #当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好 
#继承的两种含义 
#1.继承基类的方法，并做出自己的扩展（代码重用（强耦合，意义不是很大）少用） 
#2.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并实现接口中定义的方法（归一化继承）

#子类创建数据属性和函数属性，实例化后会先找子类中的属性

class Dad:
    money=10
    def __init__(self,name):
        print(\'爸爸\')
        self.name=name
    def hit_son(self):
        print(\'%s 正在打儿子\' %self.name)

class Son(Dad):
    money = 10000000
    def __init__(self,name,age):
        self.name=name
        self.age=age

s1=Son(\'alex\',\'19\')
print(s1.name)     #10000000
print(s1.money)   #\'alex\'
s1.hit_son()

 

#继承顺序
 #1.当类是经典类时，多继承情况下，会按照深度优先方式查找 
#2.当类是新式类时，多继承情况下，会按照广度优先方式查找
 #Python2.x灰分经典类和新式类，Python3.x统一为新式类
 #深度优先
 #  F->D->B->A->E->C          #从左找起 

 #广度优先 
 #  F->D->B->E->C->A           #从左找起

class A:
    def test(self):
        print(\'A\')
class B(A):
    def test(self):
        print(\'B\')
class C(A):
    def test(self):
        print(\'C\')
class D(B):
    def test(self):
        print(\'D\')
class E(C):
    def test(self):
        print(\'E\')
class F(D,E):
    pass
    # def test(self):
    #     print(\'F\')
f1=F()
f1.test()  #F->D->B->E->C->A 实在找不到才会去找A类

#接口继承，第二中继承方式（更好）（归一化设计）
 #基类中只定义方法，不写功能。而在继承基类中的类必须定义基类中所有的方法，不然会报错

import abc
class All_file(metaclass=abc.ABCMeta):#限制继承基类中的类必须定义基类中所有的方法

    @abc.abstractmethod
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass
    
class Disk(All_file):
    def read(self):
        print(\'Disk is reading\')
    def write(self):
        print(\'Disk is writing\')
        
class Mess(All_file):
    def read(self):
        print(\'Mess is reading\')
    def write(self):
        pass
m1=Mess()

#子类中调用父类的方法

 #1.这种方法扩展性差(一般不用，也不会用)

class Vehicle:
    Country=\'China\'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print(\'正在跑......\')
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
  
        Vehicle.__init__(self,name,speed,load,power) #这样调用父类方法
        self.line=line
    def run(self):
        Vehicle.run(self)          #调用父类
line1=Subway(\'13号线\',\'13Km\',\'100kg\',\'电\',\'line\')
print(line1.__dict__)  
#{\'name\': \'13号线\', \'speed\': \'13Km\', \'load\': \'100kg\', \'power\': \'电\', \'line\': \'line\'}
line1.run()

#第二种调用(更好)

#super（）

class Vehicle:
    Country=\'China\'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print(\'正在跑......\')

class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):

        # 这样调用父类方法
        #super().__init__(name,speed,load,power)#相当于下面的方法
        super(Subway,self).__init__(name,speed,load,power)
        self.line=line

    def run(self):
        super().run()        #这样调用父类方法
line1=Subway(\'13号线\',\'13Km\',\'100kg\',\'电\',\'line\')
line1.run()      #正在跑......