OOP类和对象

定以一个学生类，用来形容学生
'''
# 定义一个空的类
class Student():
    # 一个空类，pass代表直接跳过
    # 此处pass必须有
    pass

# 定义一个对象
mingyue = Student()

# 在定义一个类，用来描述听Python的学生
class PythonStudent():
    # 用None给不确定的值赋值
    name = None
    age = 18
    course = "Python"

    # 需要注意
    # 1. def doHomework的缩进层级
    # 2. 系统默认由一个self参数
    def doHomework(self):
        print("I 在做作业")

        # 推荐在函数末尾使用return语句
        return None

# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()

# 继承的语法
# 在python中，任何类都有一个共同的父类叫object

class Person():
    name = "NoName"
    age = 18
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    def sleep(self):
        print("Sleeping ... ...")
        
#父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    def make_test(self):
        print("attention")
    
t = Teacher()
print(t.name)
# 受保护不能外部访问，为啥这里可以
print(t._petname)

# 私有访问问题
# 公开访问私有变量，报错
#print(t.__score)

t.sleep()
print(t.teacher_id)
t.make_test()

# 子类和父类定义同一个名称变量，则优先使用子类本身
class Person():
    name = "NoName"
    age = 18
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    def sleep(self):
        print("Sleeping ... ...")
 
        
#父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    name = "DaNa"
    def make_test(self):
        print("attention")
        
t = Teacher()
print(t.name)

# 子类扩充父类功能的案例
# 人由工作的函数， 老师也由工作的函数，但老师的工作需要讲课
class Person():
    name = "NoName"
    age = 18
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    def sleep(self):
        print("Sleeping ... ...")
    def work(self):
        print("make some money")
        
#父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    name = "DaNa"
    def make_test(self):
        print("attention")
        
    def work(self):
        # 扩充父类的功能只需要调用父类相应的函数
        #Person.work(self)
        # 扩充父类的另一种方法
        # super代表得到父类
        super().work()
        self.make_test()
        
t = Teacher()
t.work()

# 构造函数的概念

class Dog():
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")

# 实例话的时候，括号内的参数需要跟构造函数参数匹配
kaka = Dog()

# 继承中的构造函数 - 1

class Animel():
    pass

class PaxingAni(Animel):
    pass

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
# 实例话的时候，自动调用了Dog的构造函数
kaka = Dog()

# 继承中的构造函数 - 2

class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    def __init__(self):
        print(" Paxing Dongwu")

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
        
# 实例话的时候，自动调用了Dog的构造函数
# 因为找到了构造函数，则不在查找父类的构造函数
kaka = Dog()

# 猫没有写构造函数
class Cat(PaxingAni):
    pass

# 此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数
# 在PaxingAni中查找到了构造函数，则停止向上查找
c = Cat()

# 继承中的构造函数 - 3

class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    def __init__(self, name):
        print(" Paxing Dongwu {0}".format(name))

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
        
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错      
d = Dog()

class Cat(PaxingAni):
    pass

# 此时，由于Cat没有构造函数，则向上查找
#  因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
c = Cat()

# 继承中的构造函数 - 4

class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    pass

class Dog(PaxingAni):
    pass
        
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错      
d = Dog()

class Cat(PaxingAni):
    pass

# 此时，由于Cat没有构造函数，则向上查找
#  因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
c = Cat()