#Python3面向对象继承

Python3面向对象继承

大家可以看出下面两个类class Dog和class Sheep
他们有共同的属性（weight height）和行为（ def eating(self):虽然内容不一样）
我们就将这些相同的属性和行为抽出来，独立为一个类。类就是从对象中抽出来的。

继承的作用：

class Dog:
    def __init__(self,name,weight,height,color):
        self.name = name
        self.weight = weight
        self.height = height
        self.color = color

    def bark(self):
        print("汪汪叫")

    def eating(self):
        print("吃饭")

class Sheep:
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height

    def eating(self):
        print("吃草")

抽出来并创建一个class Animal的类，但是问题又来了，那么我们怎么去调用共同属性呢，这就要用到继承了
也就是类名class Dog后面加括号并写上继承与那一个类class Dog(Animal):

class Animal:
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height
    def eating(self):
        print("吃草")
        
class Dog(Animal):
    def __init__(self,name,weight,height,color):
    super().__init__(weight,height)			#当我们想要从父类中获取父类的一部分属性的时候，
        self.name = name				#就要用到 super().__init__(父类的属性)当然父类的属性要在Dog类下面的init 参数里面要有啊，
        self.color = color				#也可以用Animal.__init__(weight,height)进行获取，即指定父类进行调取
									#但是啊用Animal.__init__(weight,height)进行获取会发现self这个用来接收对象名的参数无法传入，所以还是super进行获取
    def bark(self):
        print("汪汪叫")

    def eating(self):
        print("吃饭")

class Sheep(Animal):
    pass
        
haer = Dog("二哈",20,30,"black")   #实例化Dog类的对象haer 并录入数据"二哈",20,30,"black"
haer.bark()						#haer对象调用bark函数
#(输出)汪汪叫
haer.eating()					#haer对象调用eating函数
#(输出)吃饭

litter = Sheep(10, 20)			#同上啊
litter.eating()					#调用eating但是会发现Sheep中根本没有eating，
#(输出)吃                       #但是print 还是会输出 “吃”，而这个吃即为Sheep的父类Animal中的行为属性eating，
                               #也就是说Sheep这个类继承了父类Animal的属性代码						
print(litter.weight)		   #当子类没有的属性，系统就会向上（父类）就行查找，并且写入属性，有的话就不会向上查找
								#列如litter = Sheep(10, 20)，并没有__init__进行写入属性，就会向父类进行查找并写入Sheep类的对象litter属性
#(输出)10						

即子类继承父类的属性代码，如果查找子类时系统发现子类没有这个属性，它就会向上（它的父类去进行查找）并运用到子类上。
super().init(参数) 获取父类属性
super().(父类的函数) 也可以获取父类的函数

class Animal:
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height
    def eating(self):
        print("吃")

class Sheep(Animal):
    def eating(self):
        print("吃草")
        super().eating()		#本类有eating，但是还想对父类的eating进行一个调用，
								#super().eating()进行调用父类的函数
litter = Sheep(20,10)
litter.eating()
#(输出)	吃草
		吃

oop

什么是oop？即面向对象编程
面向对象三大特性，封装，继承，多态。
封装：将方法封装成一个函数，要用这个方法的时候，直接调用函数就可以了。隐藏内部实现，留出外部接口。将对象进行内部隐藏处理得到我们想要的想过,并传出结果。最常见于框架
继承：就是子类继承父类的属性和方法，但是有些私有的属性不能继承（比如__name 双下划线属性），父类也有叫超类，子类也有叫派生类的。

Python：继承为 多继承

class X(object):
    def f(self):
        print ('x')

class A(X):
    def f(self):
        print ('a')

    def extral(self):
        print ('extral a')

class B(X):
    def f(self):
        print('b')

    def extral(self):
        print ('extral b')

class C(A, B, X):
    def f(self):
        super().f()     
        print('c')

print (C.mro())				
#(输出)[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.X'>, <class 'object'>]

				    #MRO表返回类型方法顺序的解析表。
					#print (C.mro()) -->class C(A, B, X):-->class A(X):-->class B(X):-->class X(object):
c = C()			
c.f()		 
#(输出)	a			#class C(A, B, X):  def f(self):super().f()  到这里，super().f()调用父类函数f(),默认查找顺序为A-->B-->X，
				#如果A有就不会再继续查找下去，所以执行class A(X):输出 a，
				#然后在执行class C(A, B, X):下面的   print('c')语句
		c		
			
c.extral()			#同理上面的查找顺序
#(输出)extral a