python面向对象之继承

以你之姓@ 2021-10-20 01:32 402阅读 0赞

一、继承

面向对象的三大特性: 继承 多态 封装

初始继承：子类以及子类实例化的对象，可以访问父类的任何方法或变量

类名可以访问父类的所有内容

class Animal:
        breath = '呼吸'
    
        def __init__(self, name, sex, age):
            self.name = name
            self.sex = sex
            self.age = age
    
        def eat(self):
            print(self)
            print('动物都需要进食....')

1、初始继承：子类以及子类实例化的对象，可以访问父类的任何方法或变量

类名可以访问父类的所有内容

print(Person.breath)
        Person.eat(111)

2、class Person(Animal):  \# 括号里面的 父类,基类,超类   括号外面的 子类,派生类.  
     pass

3、子类实例化的对象也可以访问父类所有内容

print(p1.breath)
    print(p1)
    p1.eat()

4、查询顺序

只执行父类的方法:子类中不要定义与父类同名的方法
      只执行子类的方法:在子类创建这个方法.
      
    
    既要执行子类的方法,又要执行父类的方法?
    有两种解决方法.    
        1,Animal.__init__(self, name, sex, age)
        2,super().__init__(name,sex,age)
    
    课堂示例：
    class Brid(Animal):
    
        def __init__(self, name,sex,age,wing): # self b1对象 name '鹦鹉',sex '公',age 20,  wing '绿翅膀'
            '''
            self=b1对象
            name='鹦鹉'
            sex='公'
            age= 20,
            wing='绿翅膀'
            '''
            # Animal.__init__(self, name, sex, age) # 法一
            super().__init__(name,sex,age) <==缩写== # super(Brid,self).__init__(name,sex,age) # 法二
            self.wing = wing
        def bark (self):
            print('嗷嗷叫')
    
        def eat(self,argv):
            super().eat(argv)
            print('鸟吃虫子...')

5、类的分类  
新式类: 凡是继承object类都是新式类.  
  \# python3x 所有的类都是新式类,因为python3x中的类都默认继承object.

class A:
       pass

经典类: 不继承object类都是经典类  
  \#python2x:(既有新式类,又有经典类) 所有的类默认都不继承object类,所有的类默认都是经典类.你可以让其继承object.

6、继承的进阶
       继承: 单继承,多继承.

单继承: 新式类,经典类查询顺序一样.

多继承:  
           新式类: 遵循广度优先.  
           经典类: 遵循深度优先.

多继承的新式类  类名.mro() ===》（查询多继承的继承走向）

广度优先 : 一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走另一条路.如果不能,则走到终点.

多继承的经典类

深度优先 : 一条路走到底.

7、继承的优点：

优化代码,节省代码.  
             提高代码的复用性.  
             提高代码的维护性.  
             让类与类之间发生关系.

组合： 让对象与对象发生关系

作业：

试题一：  
a,定义一个父类Animal，在构造方法中封装三个属性，姓名，性别，年龄，  
再给其添加一个eat的方法，方法中显示%s正在吃饭（%s是哪个对象调用此方法，显示哪个对象名字）。  
b,定义两个子类Person,Dog，全部继承这个父类Animal.  
c,Person类中，有构造方法，封装一个皮肤的属性，有eat方法，方法中显示人类正在吃饭。  
d,Dog类中，有构造方法，封装一个毛色的属性，有eat方法，方法中显示狗狗正在吃饭。

class Animal:
        def __init__(self, name, sex, age):
            self.name = name
            self.sex = sex
            self.age = age
    
        def eat(self, argvs):
            print("%s正在吃%s" % (self.name, argvs))
    
    
    class Person(Animal):
        def __init__(self, name, sex, age, skin):
            super().__init__(name, sex, age)
            self.skin = skin
    
        def eat(self, argvs):
            super().eat(argvs)
            # print("人类正在吃饭")
    
    
    class Dog(Animal):
        def __init__(self, name, sex, age, coatcolor):
            super().__init__(name, sex, age)
            self.coatcolor = coatcolor
    
        def eat(self):
            super().eat()
            print("狗狗正在吃饭")

# ①：实例化一个人类的对象，让其只封装皮肤属性。
    p1 = Person("黄皮肤")
    print(p1.skin)
    # ②：实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
    p2 = Person("yunson", "男", 25, "黄皮肤")
    print(p2.__dict__)
    # ③：实例化一个狗类的对象，让其只封装毛色属性。
    d1= Dog("黑毛")
    print(d1.coatcolor)
    # ④：实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
    d2 = Dog("小黑", "公", 2, "黑毛")
    print(d2.__dict__)
    # ⑤：实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
    p3 = Person("yunson", "男", 25, "黄皮肤")
    p3.eat("饭")
    # ⑥：实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。
    d3 = Dog("小黑", "公", 2, "黑毛")
    d3.eat()

题二：

class A:
        name = []
    
    p1 = A()
    p2 = A()
    p1.name.append(1) 
    #因为列表是可变对象，当我们更改列表的内容时，我们只是改了内容，而没有改变的是名称空间和内存地址的对应关系，相反对于不可变对象而言，就不同了，当我们改变了内容，这就生成了新的内存地址
    # p1.name，p2.name，A.name 分别是什么？
    print(p1.name)
    print(p2.name)
    print(A.name) # 输出结果都是值为1的列表[1]