类的继承

继承概念

如果两个或者两个以上的类具有相同的属性和方法,我们可以抽取一个类出来, 在抽取的类中声明公共的部分

• 被抽取出来的类 ——父类 超类 基类
• 其他类 — 子类 派生类
• 他们之间的关系 ——子类 继承自父类

注意：若一个类没有继承其他类，则它默认继承object类，换句话说，object是一切类的基类。

单继承

简单来说,一个子类只能有一个父类,被称为单继承

演示:test.py 文件

注意:在使用继承时,尽量一个类存在于一个模块中

比如，我们定义了一个Animal的class，有一个run()方法

class Animal(object)：
	def run(self):
        print("Animal is running....")

当我们需要编写Dog和Cat类时，就可以直接从Animal类继承:

class Dog(Animal):
    pass

class Cat(Animal):
    pass

对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类，Cat和Dog类似。

继承有什么好处？最大的好处就是子类获得了父类的全部功能，由于Animal实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()的方法。

dog = Dog()
dog.run()

cat = Cat()
cat.run()

当然，也可以对子类增加一些方法，比如Dog类：

class Dog(Animal):    
    def eat(self):
        print("Eating meat....")

__slots__只对当前类的对象起作用,当子类中也添加限制的情况下,
那么在子类中限制,应该是子类与父类限制的并集.

注意:当子类中存在特有的属性的时候,我们需要重写__init__方法,这时候,
我们需要手动在子类的__init__的方法中,去调用一下父类的__init__的方法.
使用super().__init__()

练习：现在，有一个学生类和工人类，同时继承于人类
人类的特征：name ，age，money

from person import Person
from student import Student
from worker import Worker

per = Person("aa", 1, 2)
stu = Student("tom", 18, 12345, 110)
print(stu.name, stu.age)
stu.run()

print(stu.stuId)
#私有属性
#print(stu.__money)
print(stu.getMoney())#通过继承过来的共有方法访问私有属性
#stu.stuFunc()

wor = Worker("lilei", 20, 111)
print(wor.name, wor.age)
wor.eat("apple")

#子类对象调用父类同名的函数,则发现优先调用子类中的函数
#本质是子类中的方法覆盖了父类中同名的函数
wor.run()

print(per.getMoney())

#父类对象不能访问子类特有的属性或方法
#print(per.stuId)

#以前的写法 class Person(object):
#但是实质上,如果没有显示的写出父类,则这个类的父类默认为object
#object是所有类的父类或者超类
class Person(object):
    #构造方法
    def __init__(self, name, age, money):
        self.name = name
        self.age = age
        self.__money = money
        
     #get/set方法
    def setMoney(self, money):
        self.__money = money
        
    def getMoney(self):
        return self.__money
    
    def run(self):
        print("run")
        
    def eat(self, food):
        print("eat", food)
        

from person  import Person
class Student(Person):
    def __init__(self, name, age, money, stuId):
        #调用父类中的构造方法
        #方法1 super(当前类,self).__init__(参数列表)
        #super(Student,self).__init__(name, age, money, stuId)
        #方法2 父类名.__init__(属性列表)
        Person.__init__(self, name, age, money)
        #子类可以有一些自己独有的属性
        self.stuId = stuId
    def setFunc(self):
        print(self.__money)

from person import Person

class Worker(Person):
    def __init__(self, name, age, money)
    	super(Worker,self).__init__(name, age, money)
    # 在子类中定义和一个父类中重名的函数
    def run(self):
        print("子类中的run方法被调用了")

继承的特点

• 子类对象可以直接访问父类中未私有的对象
• 子类对象可以调用父类中的方法
• 父类对象不能访问子类中特有的属性或者方法

优缺点:
优点:

• 可以简化代码,减少冗余
• 提高代码的维护性
• 提高了代码的安全性

缺点:

• 耦合和内聚被用来描述类与类之间的关系,耦合性越低,内聚性越高,说明代码越好,
• 但是,在继承关系中,耦合性相对比较高,如果修改父类,子类也会随着变化

练习:
学生类
特征:姓名 性别 年龄 学号 班级 成绩
行为: 吃饭 睡觉 学习
老师类
特征:姓名 性别 年龄 工号 学科
行为:吃饭 睡觉 讲课

class Person(object):
    __slots__ = ("name","sex","age","__money")#动态添加属性方式,限制添加四个属性
    def __init__(self,name,sex,age,money):
        self.name = name
        self.age = age
        self.sex = sex
        self.__money = money  #封装,使money成为私有变量
        print("父类的构造方法被调用啦....")
    # 语法糖,打开一个缺口,使__money能被外部调用和修改
    @property
    def money(self):
        return self.__money

    @money.setter
    def money(self,mon):
        self.money = mon


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

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


class Teacher(Person):
    pass

class Student(Person):
    def __init__(self,name,sex,age,stuId,classId,score):#student的属性
        print("子类的构造方法被调用啦...")
        self.stuId = stuId
        self.classId = classId
        self.score = score
        #父类没有的属性需全部输入
        super().__init__(name,sex,age,money=0)
        #继承父类的所有属性,这里将money设定为0,外部输入参数的时候,可不输入money的值,使其默认为0



if __name__ == "__main__":
    stu = Student("小明","boy",20,"1901001","1901",90)
    print(stu.name)
    stu.eat()
    print(stu.money)
    # 打印结果
    子类的构造方法被调用啦...
	父类的构造方法被调用啦....
	小明
	吃饭...
	0

    tea = Teacher("lili","girl",20,100000)
    print(tea.name)
    # 打印结果
    父类的构造方法被调用啦....
	lili