day6-类继承

一、 概念

之前我们说到了类的公有属性和类的私有属性，其实就是类的封装。而类的继承是指可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式主要有2类：实现继承、接口继承。

a. 实现继承是指使用基类的属性和方法而无需额外编码的能力。

b. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，OO开发范式大致分为如下阶段：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现

二、继承

class Person(object):

    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.addr = "sz"
 
    def talk(self,number):
        print("person is talking..."+number)

# 继承Person这个类 
class BlackPerson(Person):

    # 既想继承属性，又想拥有自身属性，需要先继承，再重构
    # 定义时需要传入父类的属性名
    def __init__(self,name,age,strength):
        # 继承父类的构造方法
        # 经典类写法：父类.__init__(self, 属性名)
        # 新式类写法：super(子类,self).__init__(属性名)
        # super(BlackPerson,self).__init__(name,age)
        Person.__init__(self,name,age)
        # 定义子类本身的属性
        self.strength = strength   
        print(self.name,self.age,self.addr)
 
    # 定义子类自身的walk方法
    def walk(self):  
        print("BlackPerson is walking.....")

    # 重写父类的方法
    # 重写方法的方法名必须和父类中被重写的方法名一模一样
    # 重写方法的传入的参数名和参数的个数必须和父类中被重写的方法一样
    def talk(self, number):
        # 调用父类的方法
        Person.talk(self, number)  
        print("BlackPerson is talking ..."+number)
 
 
b = BlackPerson("bk",24,"strong")
# 继承父类的talk()方法
b.talk("1")
# 调用子类自身的walk方法
b.walk()  

bk 24 sz
person is talking...1
BlackPerson is talking ...1
BlackPerson is walking.....

三、实例

# coding:gbk


class SchoolMember(object):
    """学校成员基类"""

    # 设置公有属性
    member = 0

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        # 生成对象时自动注册
        self.enroll()

    def enroll(self):
        """注册"""
        print("just enroll a new school member [{0}]".format(self.name))
        SchoolMember.member += 1

    def tell(self):
        print("------info:{0}-----".format(self.name))
        # self._dict__()函数是获取对象的属性，以字典的形式返回
        for k, v in self.__dict__.items():
            print("\t", k, v)
        print("------end--------")

    def __del__(self):
        print("delete[{0}]...".format(self.name))
        SchoolMember.member -= 1


class Teacher(SchoolMember):
    """讲师类"""

    def __init__(self, name, age, sex, salary, course):
        SchoolMember.__init__(self, name, age, sex)
        self.salary = salary
        self.course = course

    def teaching(self):
        """讲课方法"""
        print("Teacher [{0}] is teaching [{1}]".format(self.name, self.course))


class Student(SchoolMember):
    """学生类"""
    def __init__(self, name, age, sex, couser, tuition):
        SchoolMember.__init__(self, name, age, sex)
        self.couser = couser
        self.tuition = tuition
        self.amount = 0

    def pay_tuition(self, amount):
        print("student [{0}] has just paied [{1}]".format(self.name, amount))
        self.amount += amount

# 注册3个成员
t1 = Teacher("zuoyi", 18, "F", 3000, "Python")
s1 = Student("zhaosan", 19, "M", "PYS15", 300000)
s2 = Student("lisi", 12, "M", "PYS15", 11000)

print(SchoolMember.member)
# 删除成员s1的引用，c此时会主动调用析构函数
del s1  # 删除一个变量
t1.tell()
s2.tell()

print(SchoolMember.member)
# 当对象在某个作用域中调用完毕，在跳出其作用域的同时析构函数也会被调用一次，这样可以用来释放内存空间
# t1、s2调用完毕，整个程序退出，析构函数被调用

just enroll a new school member [zuoyi]
just enroll a new school member [zhaosan]
just enroll a new school member [lisi]
3
delete[zhaosan]...
------info:zuoyi-----
     age 18
     name zuoyi
     salary 3000
     course Python
     sex F
------end--------
------info:lisi-----
     amount 0
     couser PYS15
     age 12
     name lisi
     tuition 11000
     sex M
------end--------
2
delete[zuoyi]...
delete[lisi]...

四、 多继承

多继承：子类继承多个父类

class SchoolMember(object):
    """学校成员基类"""

    def tell(self):
        print("the schoolmeber is tell...")


class School(object):
    """学校类"""

    def open_branch(self, addr):
        print("openning a new branch in", addr)


# 子类Teacher同时继承了SchoolMember,School两个类
class Teacher(SchoolMember, School):
    """讲师类"""
    def teaching(self):
        """讲课方法"""
        print("Teacher outman is teaching python")

t1 = Teacher()
# 继承父类SchoolMember的tell方法
t1.tell()
# 继承父类School的open_branch方法
t1.open_branch("shanghai")


the schoolmeber is tell...
openning a new branch in shanghai

五、 新式类与经典类

# 新式类：继承object类
class Person(object):  
    "新式类"
    pass

# 新式类初始化构造方法用super关键字去继承
# super(子类,self).__init__(name,age)
# 新式类多继承的调用顺序：广度优先搜索
# D-B-C-A


class A(object):  
    def __init__(self):
        self.n = "A"

class B(A):
    # pass
    def __init__(self):
        self.n = "B"

class C(A):
    # pass
    def __init__(self):
        self.n = "C"

class D(B,C):
    # pass
    def __init__(self):
        self.n = "D"

d = D()
print(d.n)

a. 直接运行
输出：D
b. 删除D的init方法
输出：B
c. 删除D和B的init方法
输出：C
d. 删除D、B、C的init方法
输出：A

上述程序的广度查询顺序：

 

# 经典类：不继承任何类
class Person:  
    "经典类"
    pass

# 经典类初始化构造方法父类.__init(self,name,age)
# 经典类多继承的调用顺序：深度优先搜索
# D-B-A-C


class A:
    # pass
    def __init__(self):
        self.n = "A"

class B(A):
    # pass
    def __init__(self):
        self.n = "B"

class C(A):
    def __init__(self):
        self.n = "C"

class D(B,C):
    # pass
    def __init__(self):
        self.n = "D"

d = D()
print(d.n)

a. 直接运行
输出：D
b. 删除D的init方法
输出：B
c. 删除D和B的init方法
输出：A
d. 删除D、B、A的init方法
输出：C

上述程序的深度查询顺序：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

小结：

1. 新式类继承object类，经典类不继承任何类

2. 新式类用super关键字继承构造方法super(子类，self).__init__(属性)，经典类用 父类.__init__(self，属性)来继承

3. 新式类：广度优先搜索，经典类：深度优先搜索

4. Python2才有上述之分，Python3中不管是经典类还是新式类均采用广度优先搜索