Python_单继承

1. 单纯封装可能会可能会出现重复的代码

面向对象编程有三大特性， 封装，继承和多态。

所谓封装就是根据职责把对象的属性和方法封装在一个抽象的类中， 我们在开发中可以使用抽象的类来创建一个实实在在的对象， 有了对象就可以访问到对象内部的属性，或者让对象来调用一个已经封装好的方法。

继承这个特性可以使用代码的重用， 用大白话来讲， 就是相同的代码不需要重复的编写，这样就可以提高开发的效率。

动物Animal 这个类中， Animal 类中，有一个吃的方法eat（）， 有一个喝的方法 drink（）， 有一个跑的方法 run（）， 一个谁的方法sleep（）。狗类Dog（）中，也有吃喝玩乐这四个方法， 除此之外， 狗还有一个特殊的方法，狗叫的方法bark（）， 在这个方法中来封装狗 汪汪叫的动作。

首先使用class 关键字来定义一个 Animal 类， 然后在类中定义一个吃的方法 eat（），定义喝的方法drink(), 定义跑的方法run（）， 定义睡的方法sleep(), 这样一个Animal类的方法就定义完成了。

有了动物Animal类 之后， 我们就使用动物Animal类 之后先来创建一个 狗对象， 起个名字叫旺财wangcai, 然后使用动物Animal类来创建一个狗对象， wangcai =  Animal(), 对象有了之后， 然后来调用吃喝玩睡的方法， 控制台输出了吃喝玩睡的执行结果。

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")

# 使用 Animal类 来创建一个 狗对象
wangcai = Animal()

# 让对象来调用一下封装在Animal 类中的方法
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()

运行结果:

 

狗类中吃喝玩睡的方法Animal 类中也有， 在狗类中我们这有一个特殊的方法， bark（）， 这个方法需要封装狗汪汪叫的动作。

先使用class 关键字来定义一个Dog 类，

哮天犬XiaoTianQuan 这个类中需要封装6 个方法， 前5个方法Dog 类中都有，

加入这些类中的共同方法，有一个需要修改，如果共同的方法是复制粘贴而来的， 就要将每个类中的这个要修改的共同方法进行修改， 工作量非常。

# 没有使用继承,而是复制粘贴, 工作量太大

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")

class Dog:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")

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

# 使用 Animal类 来创建一个 狗对象
wangcai = Dog()

# 让对象来调用一下封装在Animal 类中的方法
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()

运行结果:

2. 继承的概念和语法

所谓继承， 就是子类拥有父类的所有属性和方法， Animal 类可以看作是父类， Dog 类可以看作是子类， 在Animal 类中把动物的基本行为进行一个封装， 而Dog 类这个子类拥有 Animal 类这个父类的所有属性和方法， 因此， 一旦使用继承，我们只需要在Dog 类中， 针对 Dog 类特有的方法进行一个封装就可以了。子类中只需要来封装一下子类特有的属性和方法就可以了。

在开发时，如果希望一个类继承自另一个类， 我们就可以在类名后面跟上一对小括号（）， 然后把父类的名称放在小括号内部就可以了， 譬如， 在定义 Dog 类的时候， 就可以在Dog 类的名字后面跟上一对小括号（）， 在小括号内部跟上Animal 类的类名就可以了。 这样， 我们在使用 Dog 类创建出来的狗对象， 天生就具有父类中封装的方法了。

class Dog(Animal), 控制台就会输出 “吃 喝 玩 睡 汪汪叫”，要修改代码时，  将父类的代码进行修改就可以了。

# 让狗类继承自动物类

class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")

class Dog(Animal):

    # 子类拥有父类的所有属性和方法
    
    def bark(self):
        print("汪汪叫---")

# 使用 Animal类 来创建一个 狗对象
wangcai = Dog()

# 让对象来调用一下封装在Animal 类中的方法
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()

运行结果:

子类继承自父类， 可以直接享受父类中已经封装好的方法， 不需要再次开发。

子类中应该根据职责， 封装子类中特有的属性和方法。

3.继承的相关术语_继承和派生

基类就是父类，继承就是派生。

Dog 类是 Animal 类的子类，Animal 类是 Dog 类的父类，Dog 类从 Animal 类继承。

Dog 类是 Animal 类的派生类，Animal 类是  Dog 类的基类，Dog 类从 Animal 类派生。

4. 继承的传递性

所谓传递性， 就是父类的属性和方法，可以向他的子类， 以及子类的子类不断的传递， 用通俗的讲法， 就是儿子继承了父亲的所有属性和方法， 同时也继承了爷爷的所有属性和方法，这个就叫做继承的传递性。

哮天犬XiaoTianQuan 这个类中需要封装6 个方法， 前5个方法Dog 类中都有，让XiaoTianQuan类继承自狗类Dog类， 然后用XiaoTianQuan类创建一个对象， 看看XiaoTianQuan类创建出来的对象能不能调用封装在动物类 Animal类中的方法，

把整个动物类Animal 类 的代码进行一个折叠， 然后定义一个Dog类，让Dog类继承自Animal 类，class Dog（Animal）:, 然后使用def 关键字在Dog 类中封装一个 bark（)方法，这样Dog 类就封装完成了。

现在再来封装一个XiaoTianQuan类， 让XiaoTianQuan 这个类继承自Dog类， class XiaoTianQuan(Dog):, 继承之后， 再使用def 关键字来定义一个fly 的方法， 现在三个类定义完成了， Animal类， Dog类， XiaoTianQuan类。

接下来就在主程序中使用XiaoTianQuan这个类定义一个对象， 来尝试一下这个创建出来的对象能不能调用在Animal类中封装的方法， xtq = XiaoTianQuan(), 对象创建完成， 先让对象来调用一下在XiaoTianQuan类中封装的飞的方法， xtq.fly(), 这个方法能正常输出， 再让xtq 调用封装在Dog类（上一级父类）中的方法，xtq.bark(), 能正常执行， 再让xtq 调用封装在Animal类（上两级父类）中的方法，xtq.eat(), 同样也能正常执行。这个就是继承的一个重要特性——传递性。

class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


# 让 Dog() 类继承自 Animal 类
class Dog(Animal):

    def bark(self):
        print("汪汪叫")
    #Dog 类封装完成

# 让XiaoTianQuan 这个类继承自Dog类
class XiaoTianQuan(Dog):

    def fly(self):
        print("我会飞")
    # XiaoTianQuan 这个类定义完成

# 在主程序中来创建一个 xtq 的对象
xtq = XiaoTianQuan()

# xtq 能调用 XiaoTianQuan 类 ,Animal类和Dog 类中的方法
xtq.fly()
xtq.bark()
xtq.eat()

输出结果:

在pycharm 中， Dog()这个类左侧有个小图标， 光标放在上面后会提示，Dog 类有一个子类是XiaoTianQuan类。

同理， 如果把光标放在Animal类左侧这个小图标上， 会提示Animal类有两个子类， 一个是Dog类，一个是XiaoTianQuan类。

XiaoTianQuan类不是直接继承的Animal类， XiaoTianQuan类是从Dog类继承的， 但是由于Dog类是从Animal类继承的， 所以XiaoTianQuan 这个类创建出来的对象同样也拥有Animal 类中封装的所有属性和方法。

5.继承传递性的注意事项

假设从Animal类中派生出一个Cat类， 并且在Cat类中封装一个抓老鼠的方法， XiaoTianQuan类创建出来的对象并不能调用Cat（）类中封装的方法， 调用的话会报错。因为从图可以看成， XiaoTianQuan类和Cat 类没有直接的继承关系。

使用class 关键字来定义一个Cat(), 并且让这个Cat（）继承自Animal()类， Cat()准备完成， 就使用def 关键字在Cat 类中封装一个抓老鼠的方法， def catch()。

class Animal:

    def eat(self):
        print("吃---")

    def drink(self):
        print("喝---")

    def run(self):
        print("跑---")

    def sleep(self):
        print("睡---")


# 让 Dog() 类继承自 Animal 类
class Dog(Animal):

    def bark(self):
        print("汪汪叫")
    #Dog 类封装完成


# 让XiaoTianQuan 这个类继承自Dog类
class XiaoTianQuan(Dog):


    def fly(self):
        print("我会飞")
    # XiaoTianQuan 这个类定义完成


# 在定义一个Cat()类, 让Cat() 继承自 Animal类, 并封装一个抓老鼠的方法
class Cat(Animal):

    def catch(self):
        print("抓老鼠")

# 在主程序中来创建一个 xtq 的对象
xtq = XiaoTianQuan()

# xtq 能调用 XiaoTianQuan 类 ,Animal类和Dog 类中的方法
xtq.fly()
xtq.bark()
xtq.eat()

#xtq 并不能调用Cat 类中封装的方法
xtq.catch()  # 会报错

运行结果: