python 面向对象的三大特性之一: 继承

继承:
    继承优点:
　　　　1. 优化代码,节省代码
　　　　2. 提高代码的复用性
　　　　3. 提高代码的维护性.
　　　　4. 让类与类之间发生关系

    初识继承:
        只执行本类的方法
        只执行父类的方法
        即要执行本类方法,又要执行父类方法
            父类名,方法名(参数)
            super().方法名(参数(self自动传值))
    单继承,多继承.
    类:新式类,经典类
    单继承:
        新式类,经典类查询顺序一样.
    多继承:
        新式类:广度优先        类名.mro() 新式类.
        经典类:深度优先
    面向对象的三大特性: 继承, 多态, 封装
    继承:括号里面的 父类, 基类, 超类  括号外面的 子类,派生类
    初识继承: 子类以及子类实例化的对象,可以访问父类的任何方法和变量
    类名可以访问父类所有内容
    子类实例化的对象,也可以访问父类所有内容
　　查询顺序:
    　　子对象: 子对象首先通过在子对象空间找,在到子类中找,子类没有的话,在由子类通过指针到父类找.
    　　子类:   首先在本类找,然后再到父类找
    　　只执行父类方法:子类不要定义一个与父类相同的方法
    　　只执行子类方法:在子类创建一个这个方法
    　　即要执行子类方法,又要执行父类方法
　　有两种解决方法(列如):
    　　1. Animal.__init__(self,name,sex,age)
    　　2. super(Brid,self).__init__(name,sex,age)
　　继承的进阶
    　　继承: 单继承,多继承.
    　　类: 经典类,新式类
    　　新式类: 凡是继承object类都是新式类python3版本中,  所有的类都是新式类.因为python3x中的类都默认继承object.
    　　经典类: 不继承object类都是经典类python2x: (既有新式类,又有经典类)
    　　所有的类默认都不继承object类,所有的类默认都是经典类,你可以让其继承object
    　　单继承:  新式类,经典类查询顺序一样.
    　　继承顺序:执行的话,先从本类执行,没有的话就从父类执行.
    多继承:
        新式类: 遵循广度优先.
        经典类: 遵循深度优先.

    深度优先,广度优先: 只能是继承两个类的情况(多继承)

    多继承的新式类: 遵循广度优先: 一条路走到倒数第二级,判断,如果有其他路能走到终点,
        则返回走另一条路,如果不能,则走到终点.
    多继承的经典类: 遵循深度优先: (一条路走到底)有两条路就走第一条路

　　继承三个类顺序:本类,继承中(从左到右),第一个,第二个,第三个实现,然后由下往上依次实现.

    (列)print(F(类).mro())      # 查询类的继承顺序



1. 初识继承.

class Food:
    apple = "苹果"
    def __init__(self,banana,size,age):
        self.banana = banana
        self.size = size
        self.age = age

    def F(self):
        # print(self)     # 是哪个类(子类或者自己的类)调用这个函数,self就是哪个的对象地址
        print("多一个朋友,多一条路.")

class Good(Food):   # 继承:括号里面的 父类, 基类, 超类  括号外面的 子类,派生类
    pass

p1 = Good("香蕉","大", 1)
p1.F()

# 初识继承: 子类以及子类实例化的对象,可以访问父类的任何方法和变量
    # 子类名可以访问父类所有内容
    # 子类实例化的对象,也可以访问父类所有内容

print(p1.apple) # 查看父类的静态变量
print(Good.apple)

 

2. 继承的进阶.

class Animal:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self,a1):
        print("%s吃%s." % (self.name,a1))
    def drink(self):
        print("%s喝东西" % self.name)
class Cat(Animal):
    def miaow(self):
        print("呵呵")
class Brid(Animal):
    def __init__(self,name,sex,age,wing):

        Animal.__init__(self,name,sex,age)  # 向上传参数
        super(Brid,self).__init__(name,sex,age) # super只能在子类执行,

        self.wing = wing
    def bark(self):
        print("%s哈哈" % self.wing)
    def eat(self,a2):
        super().eat(a2)
        print("鸟喜欢吃东西...")

class Chook(Animal):
    def crow(self):
        print("大大叫")
    # def eat(self):      # 只执行自己类中的方法,但是不要传值
    #     print(666)
b4 = Brid("小明","公的",12,"小王")
b4.eat("东西")
b4.bark()
print(b4.__dict__)  # 查看本类中的所有变量

c3 = Chook("鸡","未知",23) #
c3.eat(1)   # 根据父类的eat函数中多了一个变量,所以在执行父类的函数时,要传值
c3.drink()    # 在自己类中的函数没有时,就找父类中的函数执行...
c3.eat("高")     # 在自己类中的函数没有时,就找父类中的函数执行...
print(c3.__dict__)  # 查看本类中的所有变量


# 继承的进阶
# 继承: 单继承,多继承.
# 类: 经典类,新式类
# 新式类: 凡是继承object类都是新式类
#     python3版本中,  所有的类都是新式类.因为python3x中的类都默认继承object.

 

3. 多继承的查询.

class A(object):
    def func(self):
        print("1A")
class B(A):
    def func(self):
        print("1B")
class C(A):
    def func(self):
        print("1c")
class D(B):
    def func(self):
        print("1D")
class E(C):
    def func(self):
        print("1E")
class F(D,E):
    def func(self):
        print("1F")

f1 = F()
f1.func()
print(F.mro())      # 查询类的继承顺序

# 上面是多继承的新式类
# 多继承的新式类: 遵循广度优先: 一条路走到倒数第二级,判断,如果有其他路能走到终点,
#       则返回走另一条路,如果不能,则走到终点.

# 多继承的经典类: 遵循深度优先: (一条路走到底)有两条路就走第一条路