python -- 面向对象编程(继承、重写)

一、继承

子类可以继承父类的所有公有成员，但不能直接访问父类的私有成员，只能通过父类的公有方法间接访问私有属性或私有方法。

如： class DerviedClassName（BaseClassName1[，BaseClassName2，......]）：

　　　　　　语句1

　　　　　　语句2

　　　　　　.......

　　　　　　语句N

公有属性既可以在类的内部进行访问，也可以在外部程序中使用。

派生类(子类)继承了基类(父类)的行为和属性之后，还可以增加某些特定的行为和属性。　

继承分为单继承和多继承

A、单继承

# -------------------------------------
# 继承：派生类可以继承父类的公有成员
# -------------------------------------
# 单继承
# 基类：员工
class Staff:
    school = '一中'                  # 类变量，在该类及其子类的实例中共享

    def __init__(self, name='', age=25, sex='男'):
        # 成员变量（实例变量）通常都是在此方法中定义
        self.__name = name          # 姓名
        self.__age = age            # 年龄
        self.__sex = sex            # 性别

        self.set_name(name)         # 调用方法对参数的有效性进行验证,并完成初始化
        self.set_age(age)
        self.set_sex(sex)

    def set_name(self, name):
        print("Staff: mod_name!")
        # isinstance()：测试一个对象是否为str
        if not isinstance(name, str):
            print('Name must be string.')
            # 如果数据不合法，就使用默认值
            self.__name = ''
            return

        self.__name = name

    def set_age(self, age):
        if type(age) != int:
            print('Age must be integer.')
            self.__age = 25
            return

        self.__age = age

    def set_sex(self, sex):
        if sex not in ('男', '女'):
            print("性别必须是：'男'或'女'")
            self.__sex = '男'
            return

        self.__sex = sex

# 派生类：老师（继承父类的公有成员，但不能继承其私有成员）
class Teacher(Staff):
    def __init__(self, name='', age=25, sex='男', phone=None, title=None):
        # 调用基类的构造函数
        # super(Teacher, self).__init__(name, age, sex)
        # 调用父类(基类)方法的形式一
        super().__init__(name,age,sex)     # Python 3.x 中可以使用
        # 调用父类(基类)方法的形式二
        # Staff.__init__(self,name,age,sex)
        # 增加子类特有的属性
        self.phone = phone  # 电话号码
        self.title = title  # 职称

    # 公有方法 设置/修改电话号码
    def set_phone(self, phone):
        self.phone = phone
        print("phone:", self.phone)

    def mod_title(self, title):
        self.title = title
        print("New title is:", self.title)

# 实例化员工类
staff = Staff('张楠')
# 通过对象名访问类变量
print("所属学校：", staff.school)
# 通过公有方法，修改私有变量
staff.set_age(28)
# 打印对象的属性及值
print(staff.__dict__)

# 实例化教师类
teacher = Teacher('李茜')
# 通过类名访问类变量
print("所属学校：", Teacher.school)
# 设置电话号码
teacher.set_phone('13711710932')
# 修改职称
teacher.mod_title('优秀教师')
# 设置性别
teacher.set_sex('女')
# 打印对象的属性及值
print(teacher.__dict__)

B、多继承

# ---------------------------------------------
# 继承：子类不能直接访问父类的私有属性或私有方法
# ---------------------------------------------
# 多继承
# 基类1：员工
class Staff:
    school = '一中'                  # 类变量，在该类及其子类的实例中共享

    def __init__(self, age=25, sex='男'):
        print("Staff__init__!")

        self.__age = age            # 成员变量（实例变量）通常都是在此方法中定义
        self.__sex = sex

        self.set_age(age)           # 调用方法对参数的有效性进行验证,并完成初始化
        self.set_sex(sex)

    def modify_info(self):
        print("Staff: modify_info! school:", self.school)

    def set_age(self, age):
        self.__age = age

    def set_sex(self, sex):
        self.__sex = sex

# 基类2：教师
class Teacher:
    def __init__(self, name, subject=''):
        print("Teacher__init__!")

        self.__name = name
        self.subject = subject          # 科目

    def modify_info(self):
        print("Teacher: modify_info! name:", self.__name)

    def set_subject(self, *subject):
        self.subject = subject

# 派生类：高级教师（同时继承员工类和教师类）
class SeniorTeacher(Staff, Teacher):
    def __init__(self, name='', age=25, sex='男', subject='', level=''):
        # 调用基类构造方法初始化基类的私有数据成员
        Staff.__init__(self, age, sex)
        Teacher.__init__(self, name, subject)

        self.level = level              # 考核等级

    def set_level(self, level):
        self.level = level
        print("New level is:", self.level)

# 实例化
s_teacher = SeniorTeacher('张默', age=28, sex='男', subject='物理', level='优秀')

# 设置年齡（继承于第一个基类）
s_teacher.set_age(30)

# 设置科目（继承于第二个基类）
s_teacher.set_subject('化学')

# 调用基类公有方法（两个基类都有此方法）
s_teacher.modify_info()

二、重写（不想要父类的某些特性，想拥有自己的特性）

如果从父类继承的方法不能满足子类的需求，可以在子类中重写父类的方法，这个过程称为方法的覆盖（override），也称为方法的重写。

# ---------------------------
# 重写
# ---------------------------
# 定义父类
class Father:
    def __init__(self, name):
        self.name = name
        print("name: %s" % self.name)

    def get_name(self):
        return "Father's name:" + self.name

# 定义子类，继承父类
class Son(Father):
    # 继承父类构造方法，并进行改写
    def __init__(self, name):
        # 调用父类方法的形式一
        super(Son, self).__init__(name)
        # super().__init__(name)            # Python 3.x 中可以使用

        # 调用父类方法的形式二
        # Father.__init__(self, name)

        # 然后再执行子类自己的一部分操作
        self.name = name
        print("Hello! Subclass's initialize function.")

    # 重写get_name方法
    def get_name(self):
        return "Son's name:" + self.name

# 如果直接运行脚本，执行下面的代码
#如你叫小明.py，你在朋友眼中是叫小明,name,而在你自己眼中是name==mian,即小明.py
if __name__ == '__main__':
    # 实例化子类
    son = Son('Danny')
    # 调用子类对象的方法
    print(son.get_name())