W6_面向对象_封装_继承_多继承_多态

W6_面向对象_封装_继承_多继承_多态

• 80.81.82.83.第02章节-Python3.5-面向对象介绍
• 84.第05章节-Python3.5-实例变量与类变量
• 85.第06章节-Python3.5-类变量的作用及析构函数
  • 类变量
  • 析构函数：
  • 私有属性
• 86.第07章节-Python3.5-类的继承
• 87.第08章节-Python3.5-类的继承2
• 88.第09章节-Python3.5-经典类与新式类的继承顺序
  • 深度优先
  • 广度优先
• 89.第10章节-Python3.5-继承实例讲解
• 90.第11章节-Python3.5-多态实例讲解
• 91.practice-选课系统

80.81.82.83.第02章节-Python3.5-面向对象介绍

class Role(object):
    n = 123        #类变量
    def __init__(self,name):  #构造函数
        self.name = name      #实例变量，作用域就是实例本身，又称为类的静态属性
    def got_shot(self):       #类的方法，又称为类的动态属性
        print(self.name,"get shot")

r1 = Role("alex")   #实例化
r1.got_shot()

84.第05章节-Python3.5-实例变量与类变量

若类变量与实例变量同名时，优找实例中的变量

class Role(object):
    n = 123        #类变量
    def __init__(self,name，weapon,life_value=100):  #构造函数
        self.name = name     #实例变量，作用域就是实例本身，又称为类的静态属性
        self.weapon = weapon
        self.__life_value = life_value      
    def got_shot(self):       #类的方法，又称为类的动态属性
        print(self.name,"get shot")

    def __del__(self):   #析构函数
        print("%s 彻底死了" % self.name)

r1 = Role("alex","ak47")   #实例化
r2 = Role("jack","knife")   #实例化
r1.got_shot()
del r2  #销毁实例，其本质是删除变量 ，并非清空内存地址的内容

类变量与实例变形：
print(r1.n,r2.n,Role.n,100)
r1.n = "abc" #这样赋值相当于在r1 内存地址中增加了一个变量名为n,并赋值为abc
当r1去找n时，就优先找到自己存内存区域中的n
print(r1.n,r2.n,Role.n,100)

85.第06章节-Python3.5-类变量的作用及析构函数

类变量

类变量的作用：实例共用的属性，节省开销

析构函数：

在实例释放或销毁时执行的，通常用于做一些收尾工作，比如关闭一些数据库连接，打开的临时文件等

变量名在，则内存地址不被回收，如果变量名被删除，则内存地址到期被回收
del r1 销毁r1实例,即删除变量名

私有属性

私有属性，不希望其它实例访问
格式：方法或属性前加双下划线即可

class Role(object):

    def __init__(self,name,life_value=100):
        self.name = name
        self.__life_value = life_value  #加双下划线，表示私有方法，外部不可访问
    def got_shot(self):
        print(self.name,"get shot")
    def show_life_value(self):
        print(self.__life_value)

r1 = Role("alex")
r1.got_shot()
r1.show_life_value()

86.第07章节-Python3.5-类的继承

方法垂柳：

class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eating(self):
        print("%s is eating" % self.name)

    def sleep(self):
        print("%s is sleeping"%self.name)

class Man(People):
    def sleep(self):      #方法重构，不但实际了父类的方法，还增加了新的功能
        People.sleep(self)
        print("Man is sleep")

m1 = Man("xiaoming",22)
m1.sleep()

87.第08章节-Python3.5-类的继承2

重构构造函数

class Man(People):
    def __init__(self,name,age,money):  构造函数重构
        People.__init__(self,name,age)
        super(Man,self).__init__(name,age)   #新式类写法，与上一句功能相同
        self.money = money
        print("%s 一出生就有%s money"%(self.name,self.money))

    def sleep(self):     
        People.sleep(self)
        print("Man is sleep")

m1 = Man("xiaoming",22,100)
m1.sleep()

多继承

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eating(self):
        print("%s is eating" % self.name)

    def sleep(self):
        print("%s is sleeping" % self.name)


class Relation(object):
    def make_friends(self, obj):
        print("%s make friends with %s" % (self.name, obj.name))


class Man(People, Relation):  # 多继承
    pass


m1 = Man("m1", 22)
m2 = Man("m2", 23)
m1.make_friends(m2)

88.第09章节-Python3.5-经典类与新式类的继承顺序

#class A:              #经典类的写法
class A(object):       #新式类的写法
    def __init__(self):
        print("A")

class B(A):
    pass
    # def __init__(self):
    #     print("B")


class C(A):
    def __init__(self):
        print("C")


class D(B,C):
    pass
    # def __init__(self):
    #     print("D")

d = D()

深度优先

python2中，经典类的继承顺序为深度优先，新式类的继承顺序为广度优先

广度优先

python3中，经典类和新式类的继承顺序统一为广度优先

89.第10章节-Python3.5-继承实例讲解

class School(object):
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.staffs = []
    def enroll(self):
        pass
    def hire(self):
        pass

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        pass

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

    def teach(self,stu_object):
        pass
    def tell(self):
        pass

class Student(SchoolMember):
    def __init__(self,name,age,sex,id,grade):
        super(Student,self).__init__(name,age,sex)
        self.id = id
        self.grade = grade

    def tell(self,name,age,sex,id,grade):
        print(```
        -----student info----


          ```)

    def pay_tuition(self,amount):
        pass

school = School("School_NO1","School_NO2")
# t1
# t2
# s1
# s2
# school.hire(t1)
# school.hire(t2)
# school.enroll(s1)
# school.enroll(s2)
# print(school.students)
# print(school.staffs)
# school.staffs[0].teach()

90.第11章节-Python3.5-多态实例讲解

91.practice-选课系统

角色:学校、学员、课程、讲师
要求:

1. 创建北京、上海 2 所学校

2. 创建linux , python , go 3个课程 ， linuxpy 在北京开， go 在上海开

3. 课程包含，周期，价格，通过学校创建课程

4. 通过学校创建班级， 班级关联课程、讲师

5. 创建学员时，选择学校，关联班级

6. 创建讲师角色时要关联学校，

7. 提供两个角色接口
   6.1 学员视图， 可以注册， 交学费， 选择班级，
   6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
   6.3 管理视图，创建讲师， 创建班级，创建课程

8. 上面的操作产生的数据都通过pickle序列化保存到文件里