第十天

继承

python讲师，
名字、性别、所在小组
自我介绍
授课：打开pycharm，输入一些代码，讲解知识。。。

java 讲师
名字，性别，所在小组
自我介绍
授课：打开eclipse，输入代码，讲解知识。。。

class pythonteacher:
    def __init__(self,name,gender,group):
        self.name=name
        self.gender=gender
        self.group=group
    def introduce(self):
        print("正在做自我介绍：我叫{}，{}，所在小组是{}".format(self.name,self.gender,self.group))
    def teach(self):
        print("打开pycharm")
        print("输入代码")
        print("讲解")

class javateacher:
    def __init__(self,name,gender,group):
        self.name=name
        self.gender=gender
        self.group=group
    def introduce(self):
        print("正在做自我介绍：我叫{}，{}，所在小组是{}".format(self.name,self.gender,self.group))
    def teach(self):
        print("打开eclipse")
        print("输入代码")
        print("讲解")

"""
问题：两个类非常相似，代码大量重复，当修改某一个代码的时候，会造成大量的修改。
"""
"""
一、继承的定义
继承实现的是一种[一般]和[特殊]之间的关系
场合：如果两个类型之间存在一般和特殊的关系，水果、苹果、香蕉
一般类：父类
特殊类：子类
当子类继承父类的时候，子类可以继承父类中所定义成员（类属性、类方法、实例属性、实例方法、静态方法）
跟自己拥有这些成员一样去使用
"""

二、 继承的实现
 1. 继承方式：显示继承，隐式继承
 (1) 显示继承
# 语法class B(父类)：
#        pass
class Fruit:
    def show(self):
        print("水果")
class Apple(Fruit):
    pass
f=Fruit()
f.show()
a=Apple()
a.show()

# 继承的意义
# 父类有一些方法（产业），子类可以直接拿来用。
 (2) 隐式继承
# 在python中，如果没有写明()里去继承哪一个父类，叫隐式继承，继承的是object这个类

 2. 两个内建函数
# 用来判断父子关系或者是否属于某个类的对象
# isinstance 用来判断object对象是不是某一个type类(包含了父类)产生,返回值布尔类型

isinstance(object,type)
isinstance(f,Fruit)
isinstance(a,Fruit)
isinstance(a,Apple)
isinstance(f,Apple) #False

# issubclass(a,b) 判断a是不是b的子类，返回值布尔类型
# 自己也算是自己的子类
# issubclass(子类，父类)
issubclass(Apple,Fruit)
issubclass(Fruit,Fruit)
issubclass(Apple,object)
issubclass(Fruit,object)

# 应用场景
# 学生Student
class Student:
    pass
class student_little(Student):
    pass
class student_middle(Student):
    pass
class student_big(Student):
    pass
c=student_little()
# 当我需要判断是不是学生类型才行？
# type(p)==Student or type(p)==student_big
print(issubclass(type(c),Student))
print(isinstance(c,Student))

 3. 成员的继承
# 类属性、类方法、实例属性、实例方法、静态方法
 (1). 类属性、类方法、实例方法、静态方法
class Bike:
    brand="飞鸽"
    @classmethod
    def copybike(cls):
        print("仿造一辆自行车")

    def bybike(self):
        print("骑自行车")
        print("双手扶把...")
    @staticmethod
    def sm():
        print("这是static方法")

class Sonbike(Bike):
    def bybike(self):
        print("双手扶把")
        print("骑自行车")
    pass
s=Sonbike()
# 调用类属性和方法
print(Sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
Sonbike.sm()

 (2) 方法的重写
# 当子类继承父类时候，子类的方法需要覆盖父类的方法，叫做方法的重写
# 当子类对象访问方法的时候，如果子类重写了父类的方法，会访问子类自己的方法，
# 否则（没有重写），那么会访问父类的方法

class bike:
    brand="飞鸽"
    @classmethod
    def copybike(cls):
        print("仿造一辆自行车")

    def bybike(self):
        print("骑自行车")
        print("双手扶把...")
    @staticmethod
    def sm():
        print("这是static方法")
class sonbike(bike):
    # 对父类的bybike进行重写
    def bybike(self):
        print("子类的bybike方法")
        # print("骑自行车")
        # print("双手扶把")
        super().bybike()
s=sonbike()
# 调用类属性和类方法
print(sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
sonbike.sm()

# 当父类的方法中有部分内容是可以被重用，可以super().父类的方法
# super()代表父类产生的对象

 (3) 实例属性的继承
class bike:
    def __init__(self):
        self.color="蓝色"
        self.size=24
    brand="飞鸽"
    @classmethod
    def copybike(cls):
        print("仿造一辆自行车")

    def bybike(self):
        print("骑自行车")
        print("双手扶把...")
    @staticmethod
    def sm():
        print("这是static方法")
class sonbike(bike):
    def __init__(self):
        # self.color="白色"
        self.ischangev=True
        super().__init__()
    # 对父类的bybike进行重写
    def bybike(self):
        print("子类的bybike方法")
        # print("骑自行车")
        # print("双手扶把")
        super().bybike()
s=sonbike()
# 调用类属性和类方法
print(sonbike.brand)
sonbike.copybike()
# 实例方法和静态方法
s.bybike()
sonbike.sm()
print("sonbike",s.color)

print(s.color)
print(s.size)
print(s.ischangev)


class People:
    # 初始化函数
    def __init__(self,name,age,weight):
        self.name=name
        self.age=age
        self.weight=weight
        #对象函数
    def sleep(self):
        print("这是People类中的sleep函数")
    # 根据工作时间，计算体重是否减少的功能函数
    def work_time(self,time):
        # 如果工作时间在8-12小时范围内，体重-2
        # 如果工作时间超过12小时，体重-5
        if 8<time<=12:
            #体重-2
            self.weight-=2
        elif time>12:
            # 体重-5
            self.weight-=5
# 声明Man类，继承自People类

class Man(People):
    # Man类中的初始化函数
    def __init__(self,name,age,sex,weight,height):
        # 调用父类的初始化，将父类中的属性进行初始化，并且将self对象作为参数传递到父类的初始化函数中
        super(Man,self).__init__(name,age,weight)
        # 初始化当前类拥有的属性
        self.sex=sex
        self.height=height
    def somking(self):
        print("这是Man中smoking函数")
    # 1. 完全重写一个sleep函数
    def sleep(self):
        # 在这个sleep函数中，可以执行和父类完全不同的功能
        print("这是一个Man类中的sleep函数")
    # 2. 重写work_time函数
    def work_time(self,time):
        # 2.1 根据实际计算体重
        # 先去执行父类中work_time()函数，计算体重
        super(Man, self).work_time(time)
        # 2.2 根据体重 判断身材是否标准
        # 再去添加额外的功能代码
        # 身高-105=体重 身材标准
        # 身高-105>体重 身材偏瘦
        # 身高-105<体重 身材偏胖
        result=self.height-105
        if result>self.weight:
            print("身材偏瘦")
        elif result<self.weight:
            print("身材偏胖")
        else:
            print("身材标准")
# 创建People对象p1
p1=People("张三",22,180)
p1.sleep()
p1.work_time(13)
print("p1工作之后的体重：{}".format(p1.weight))
m=Man("李四",23,"男",75,180)
m.sleep()
m.somking()
# m在执行work_time函数时，除了要计算体重之外，还要判断身材是否标准
m.work_time(9)
print("m工作之后的体重：{}".format(m.weight))

　　

 4. 私有属性的继承

class Father:
    def __m(self):
        print("这是父类的私有方法")
class Son(Father):
    def p(self):
        self._Father__m()  # 不建议子类中使用“真名”去访问
son=Son()
son.p()


 5. 多继承
# python支持多继承(多个父类)
# 正方形  特殊的矩形
# 正方形  特殊的菱形

class Rectangle:
    def area(self):
        print("这是求矩形面积的方法")
class Diamond:
    def area(self):
        print("这是求菱形面积的方法")
        # super().area()
class Square(Rectangle,Diamond):
    def t(self):
        # self.area()
        # Rectangle.area(self)
        super().area()
s=Square
s.t()
d=Diamond()
d.area()
# 第一种方式：可以使用继承顺序条件
# 第二种放肆，在调用方法的时候，可以指定父类.方法

# 继承：MRO原则：深度优先，一个分支一个分支的去找
# 如果一个对象调用方法是其中一个父类的方法，如果父类中没有继续向上继承的父类，也没有对应的方法
# 按照MRO原则会去找原来子类平行的父类中方法


多态：
运行期：真正的去执行py文件
编译期：py被解释器翻译的时候
python鸭子类型，动态，强类型语言
多态体现的是变量、属性、对象来说，体现了不同形式。

class Father:
    def talk(self):
        print("father talk")
class Son(Father):
    def talk(self):
        print("son talk")
f=Father()
s=Son()

s.talk()
f.talk()