类的封装、继承、多态

# -*- coding: utf-8 -*-

# 面向对象编程的三个特点：封装、继承、多态

# 函数是封装代码的基本单位，类和对象的封装是属于更高级的封装方式，在类中经常会声明一些对象属性，用来保存数据的，在类中声明的函数，是用来操作数据的，不同的功能可以封装不同的函数

# 继承特点：
# 1.子类继承父类，子类拥有父类的所有属性和函数
# 2.子类继承父类，子类可以用自己独有的属性和函数,但是父类不可以使用子类独有的属性和函数
# 3.子类继承父类，子类可以重写父类的函数
#   为什么要重写父类函数？一般都是因为父类中的函数满足子类功能的需求，才会去重写父类函数
#   3.1 完全重写  在子类中，重新定义一个和父类函数名称一样的函数，并且在该函数中执行的功能和父类完全不同
#   3.2 部分重写  在子类中，重新定义一个和父类函数名称一样的函数，在重写的函数中调用了父类中的函数，先执行了父类中原有的功能，然后在该函数中添加额外功能的代码，这样的话，既保留了父类原有功能，又扩展了这个函数新的功能

# object 顶级父类 python中所有的类都是直接或者间接继承自object
class People(object):
    # 初始化函数
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight

    # 对象函数
    def sleep(self):
        print('这是People类中的slepp函数')
    # 根据工作时间，计算体重是否减少的功能函数
    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工作之后的体重：%s'%p1.weight)

# 父类不可以使用子类单独拥有的属性和函数
# print(p1.sex)
# p1.somking()

# 创建Man类的对象
m = Man('李四', 22, '男', 70, 180)
# m.sleep()
# m在执行work_time函数时，除了要计算体重之外，还要判断身材是否标准
m.work_time(12)
print('m工作之后的体重：%s'%m.weight)

# -*- coding: utf-8 -*-


# 声明一个类型
class People(object):
    # 类变量
    file_name = 'student.txt'

    def __init__(self, name, school):

        self.name = name
        self.school = school
        # 属性对应的是列表
        self.pdc = []
        # 属性也可以是一个字典
        self.pdc_dict = {}

    # 保存数据的函数
    def save_data(self):
        # 1.打开文件
        f = open(self.file_name, 'a')
        # 2.写入数据
        f.write(self.name)
        f.write(';')
        f.write(self.school)
        f.write('---->')
        # 将素有的前任名称拼接成一个字符串
        pdc_str = ' '.join(self.pdc)
        f.write(pdc_str)
        f.write('\n')
        # 3.关闭文件
        f.close()
    # 读取数据的函数


People.file_name = 'stu.txt'
# 创建People对象
# 对象有保存信息到本地的函数
p1 = People('张三', 'shanghai')
# p1.save_data()
p2 = People('李四', 'beijing')
# p2.save_data()
# 获取对象的属性值，这个属性值是一个列表
p1.pdc.append(p2.name)
print(p1.pdc)

p3 = People('花花', 'tianjing')
# p1.pdc是一个列表，列表的增删改查都可以正常操作
p1.pdc.append(p3.name)
print(p1.pdc)
# 遍历p1的所有前任名称
for name in p1.pdc:
    print(name)

p1.save_data()