Python基础-10-继承

面向对象特性—继承

继承概念

（1）对于面向对象的继承来说，就是将多个类的共有方法提取到一个父类当中，子类只需要继承父类，可以继承多个类；

（2）子类可以新增自己的功能

（3）子类可以重写父类的方法（重写：重写父类的方法，即函数名相同，功能不同）

（4）新式类只会执行一次__init__()文件（即使有很多个父类也只会执行最近的那一个init）

 

继承的分类

（1）完全继承：子类不需要做任何操作，即可获得父类所有的方法和属性，也可以新增方法和属性

（2）部分继承/改写：子类对父类里面的部分属性或者是函数，想重新定义或修改

 

单继承与多继承

（1）【单继承】格式：class Dog(Animal):

子类：继承 是被继承类的子类

父类：被继承的类，又叫基类

 

① 代码：

#coding:utf-8

# 定义一个People父类
class People():
    age = 18
    def eat(self):
        return "这是调用【People】父类eat..."

    def drink(self):
        return "这是调用【People】父类drink..."

# 定义一个Student子类，继承People父类
class Student(People):
    def study(self):
        return "这是调用【Student】子类study..."

# 定义一个Teacher子类，继承People父类
class Teacher(People):
    def teach(self):
        return "这是调用【Teacher】子类teach..."


stu = Student()
print("stu.study():", stu.study())
print("stu.eat():", stu.eat())

te = Teacher()
print("te.teach():", te.teach())
print("te.drink():",te.drink())

② 结果：

 

（2）【多继承】格式：class SmallDog(Dog,Animal):

可以同时继承多个父类；

优先级：py3默认新式类（父类继承的是object类） 广度优先的顺序继承（先找父类-父类的父类）

           py2默认经典类，深度继承顺序（直接找最顶层的（即最有“权威”的））

① 代码：

#coding:utf-8

class A():
    def print_info(self):
        return "----执行A类的print方法----"

class B(A):
    def print_info(self):
        return "----执行B类的print方法----"

class C(B):
    pass

class D(C,A):
    pass

class E(B,A):
    pass

a =A()
print("a.print_info():", a.print_info())

b = B()
print("b.print_info():", b.print_info())

c = C()
print("c.print_info():", c.print_info())

d = D()
print("d.print_info():", d.print_info())

e = E()
print("e.print_info():", e.print_info())

 

② 结果：

 

 

（3）父类中的私有属性和方法

①私有的属性，不能通过对象直接访问，但是可以通过方法访问

②私有的方法，不能通过对象直接访问

③私有的属性、方法，不会被子类继承，也不能被访问

④一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

 

#coding:utf-8

# 定义有一个Animal父类
class Animal():
    def __init__(self, name="动物",color="白色"):
        self.__name = name
        self.color = color

    def __print_test(self):
        print(self.__name)
        print(self.color)

    def print_test(self):
        print(self.__name)
        print(self.color)

# 定义一个Dog子类继承Animal父类
class Dog(Animal):
    def dog_test_001(self):
        # print(self.__name)  # 不能访问父类的私有属性
        print(self.color)

    def dog_test_002(self):
        # self.__print_test() # 不能访问父类的私有方法
        self.print_test()

a = Animal()
# print(a.__name) # 程序报错，不能在类以外访问私有属性
print(a.color)
# a.__print_test() # 程序报错，不能在类以外访问私有方法
a.print_test()

print("-----------分割线------------")

d = Dog(name="哈巴狗",color="黄色")
d.dog_test_001()
d.dog_test_002()

 

结果：

 

在子类中调用父类方法

（1）super(子类名，self).方法名（参数）

（2）super().方法名（参数）

（3）父类名.方法名(self,参数)

注：有参数传参，没有就（）

① 代码：

#coding:utf-8

# 定义一个People父类
class People():

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        return "这是调用【People】父类eat..."

    def drink(self,drink_name):
        return "这是调用【People】父类drink...喝的是{}".format(drink_name)

# # 定义一个Student子类，继承People父类
class Student(People):

    def __init__(self, name, age):
        super(Student, self).__init__(name,age)
        self.addr = "wuxi"  # 子类增加的子类属性

    def eat(self):  # 重写父类的方法，在方法中先访问父类方法
        super().eat()
        return "这是调用【Student】子类eat..."

    def stu_drink(self,drink_name): # 子类新增的方法，在方法中先访问父类方法
        super().drink("tea")
        return "这是调用【Student】子类stu_drink...喝的是{}".format(drink_name)

stu = Student("suner", 20)
print("stu.eat():", stu.eat())
print("stu.drink():", stu.drink("blank tea"))
print("stu.stu_drink():", stu.stu_drink("green tea"))

② 结果：

 

总结

（1）子类在继承的时候，在定义类时，小括号()中为父类的名字。

（2）子类继承后，父类的属性、方法，都会被继承给子类。

（3）私有的属性，不能通过对象直接访问，但是可以通过方法访问。

（4）私有的方法，不能通过对象直接访问。

（5）私有的属性、方法，不会被子类继承，也不能被访问