定义一个学生类Java 定义一个学生类继承person类

"""
父类：人（Person），属性包含 姓名、年龄、性别
子类1：教师（Teacher），属性包含 科目、教龄
子类2：学生（Student），属性包含 班级、分数

继承的好处：
    新类不需要重头编写
    子类继承父类所有的属性和方法
    子类只需要实现缺少的新功能

在定义继承类的时候，要注意：
    1、class Student()定义的时候，需要在括号内写明继承的类Person
    2、在__init__()方法，需要调用：python2.x中 super(Student, self).__init__(name, gender)，来初始化从父类继承过来的属性，
       python3.x中 super().__init__(name, gender) 简化了
"""
class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


# 接着定义Student类，在定义Student类的时候，由于继承了Person类，所以Student类自动拥有name、gender属性，
# 因此，在定义Student类的时候，只需要把额外的属性加上即可。
class Student(Person):
    def __init__(self, name, age, gender, classes, scores):
        super(Student, self).__init__(name, age, gender)
        self.classes = classes
        self.scores = scores


student = Student('zoey', 18, 'female', '高三5班', 100)
print(student.name)
print(student.classes)

"""
打印结果：
zoey
高三5班
"""

# 练习：参考Student类，编写Teacher类，老师拥有任教某个科目的属性
class Teacher(Person):
    def __init__(self, name, age, gender, subject):
        super().__init__(name, age, gender)
        self.subject = subject


teacher = Teacher('cibo', 19, 'male', 'English')
print(teacher.name)
print(teacher.subject)

"""
打印结果：
cibo
English
"""



"""
判断类型：通过函数isinstance()可以判断一个变量的类型。

下述例子说明：
1、一个父类的实例不能是子类类型，因为子类比父类多了一些属性和方法。
2、student 也是Person类型，因为Student继承自Person，虽然它比Person多了一些属性和方法，但是，把 student 看成Person的实例也是可以的。
这说明在一条继承链上，一个实例可以看成它本身的类型，也可以看成它父类的类型
"""
# 直接实例化上述的类
person = Person('xixi', 2, 'female')
print(isinstance(person, Person))
print(isinstance(person, Student))
print(isinstance(person, Teacher))

"""
打印结果：
True
False
False
"""

print(isinstance(student, Person))
print(isinstance(student, Student))
print(isinstance(student, Teacher))

"""
打印结果：
True
True
False
"""

print(isinstance(teacher, Person))
print(isinstance(teacher, Student))
print(isinstance(teacher, Teacher))

"""
True
False
True
"""


# Python自有数据类型的判断
s = 'this is string'
n = 10
print(isinstance(s, int))       # False
print(isinstance(s, str))       # True
print(isinstance(n, int))       # True
print(isinstance(n, str))       # False

print('________________________________')


"""
类的多态：
    下述例子，从定义上来讲，Student和Teacher都拥有来自父类Person继承的who()方法，以及自己定义的who()方法。
    但是在实际调用的时候，会首先查找自身的定义，如果自身有定义，则优先使用自己定义的函数；如果没有定义，则顺着继承链向上找。
"""
class PersonA:
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def who(self):
        return 'I am a Person, my name is %s' % self.name


class StudentA(PersonA):
    def __init__(self, name, gender, scores):
        super().__init__(name, gender)
        self.scores = scores

    def who(self):
        return 'I am a Student, my name is {}'.format(self.name)


class TeacherA(PersonA):
    def __init__(self, name, gender, subject):
        super().__init__(name, gender)
        self.subject = subject

    def who(self):
        return 'I am a Teacher, my name is {}'.format(self.name)


p = PersonA('Tim', 'Male')
s = StudentA('Bob', 'Male', 88)
t = TeacherA('Alice', 'Female', 'English')
print(p.who())
print(s.who())
print(t.who())


# 在Boss的定义类，没有定义who方法，所以会顺着继承链向上找到父类的who方法并且调用
class Boss(PersonA):
    def __init__(self, name, gender, company):
        super().__init__(name, gender)
        self.company = company

b = Boss('Cibo', 'male', 'tenxun')
print(b.who())



"""
类的多重继承：
    除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。
    多重继承和单继承没有特别大的差异，只是在括号内加入多个需要继承的类的名字即可。
    当 D 里面没有调用的参数时，到父类里找。D 的父类是 B 和 C，且定义的顺序是 B在左，C在右。继承顺序是从左到右的。
    当在B中找到需调用的参数时，就停止。当B中没有时，再到C中找。当B和C都没有时，再到A中找。

python继承方式有两种：深度优先、广度优先。

新式类：python3.x的所有类都会自动转换为一个新式类,不论是否有继承object对象。 python2.x必须显式地指定类继承object父类才表示新式类。   
    1、py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的。
    2、py3 经典类和新式类都是统一按广度优先来继承的。
"""
class A:
    def __init__(self, a):
        self.a = a
        print('init A...')

class B(A):
    def __init__(self, a):
        super().__init__(a)
        print('init B...')

class C(A):
    def __init__(self, a):
        super().__init__(a)
        print('init C...')

class D(B, C):
    def __init__(self, a):
        super().__init__(a)
        print('init D...')


d = D('d')


"""
打印结果：采用广度优先的算法：D->B->C->A
A虽然被继承了两次，但是__init__()的方法只调用一次。
多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。
init A...
init C...
init B...
init D...
"""



# 已知类Student、Teacher继承Person类，技能类BasketballMixin、FootballMixin继承SkillMixin类，
# 请通过多重继承，分别定义“会打篮球的学生”和“会踢足球的老师”。
class PersonB:
    def __init__(self):
        print('person......')

class StudentB(PersonB):
    def __init__(self):
        super().__init__()
        print('student.....')

    def people(self):
        return 'student!!!!!!'

class TeacherB(PersonB):
    pass

class SkillMixin:
    def __init__(self):
        print('skill......')

class BasketballMixin(SkillMixin):
    def skill(self):
        return 'basketball'

class FootballMixin(SkillMixin):
    def __init__(self):
        super().__init__()
        print('football......')

    def skill(self):
        return 'football'

class BStudent(BasketballMixin, StudentB):
    pass

class FTeacher(FootballMixin, TeacherB):
    pass


s = BStudent()
# print(s.skill())
# print(s.people())

t = FTeacher()
# print(t.skill())