组合与封装

一、组合

什么是组合
- 组合指的是一个对象中，包含另一个或多个对象
为什么要用组合
- 减少代码的冗余
耦合度
- 耦合度越高，程序的可扩展性越低
- 耦合度越低，程序的可扩展性越高
继承
- 继承是类与类的关系，子类继承父类的属性/方法，子类与父类是一种“从属”关系
组合
- 组合是对象与对象的关系，一个对象拥有另一个对象中的属性/方法

# 组合实现
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


# 老师类
class Teacher(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)


# 学生类
class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)


# 日期类
class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tell_bir(self):
        print(f"""
        年：{self.year}
        月：{self.month}
        日：{self.day}
        """)


tea1 = Teacher('tank', 17, 'male')
tea1_date_obj = Date(2000, 6, 6)
print(tea1.name, tea1.age, tea1.sex)
tea1_date_obj.tell_bir()
stu1 = Student('cxy', 18, 'female')
stu1_date_obj = Date(2000, 9, 18)
print(stu1.name, stu1.age, stu1.sex)
stu1_date_obj.tell_bir()

组合练习

"""
练习需求
选课系统：
    1、有学生类、老师类、学生与老师有属性"名字，年龄，性别，课程"
    2、有方法 老师与学生可以添加课程，打印学习／教授课程
"""

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

    # 打印出生日期方法
    def tell_birth(self):
        print(f"""
        年:{self.date_obj.year}
        月:{self.date_obj.month}
        日:{self.date_obj.day}
        """)

    # 添加课程
    def add_course(self, course_obj):
        self.course_list.append(course_obj)

    # 打印当前对象中课程列表的所有课程信息
    def tell_all_course_info(self):
        # 从当前对象中课程列表中取出所有的课程对象
        for course_obj in self.course_list:
            # 通过课程对象，打印课程信息方法
            course_obj.tell_course_info()


class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


class Teacher(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day


# 定义一个课程类：课程有：课程名称，课程价格，课程周期
class Course:
    def __init__(self, course_name, course_price, course_time):
        self.course_name = course_name
        self.course_price = course_price
        self.course_time = course_time

    # 定义打印课程方法： 只打印一个课程信息
    def tell_course_info(self):
        print(f"""
        课程名称：{self.course_name}
        课程价格：{self.course_price}
        课程周期：{self.course_time}
        """)


# 创建学生对象
stu1 = Student('cxy', 18, 'female')
date_obj = Date(1997, 10, 19)
stu1.date_obj = date_obj

# 创建课程对象
python_obj = Course('python', 20000, 6)
go_obj = Course('go', 20000, 4)

# 当前学生添加课程对象
stu1.add_course(python_obj)
stu1.add_course(go_obj)

# 打印学生打印所有课程信息
stu1.tell_all_course_info()

二、封装

什么是封装
- 封装指的是可以将一堆属性和方法，封装到对象中
ps：对象就好比一个“容器/袋子”，可以存放一堆属性和方法

存不是目的，目的是为了取，可以通过“对象.”的方式获取属性或方法
为什么要封装
- 可以通过“对象”的方式“存放/获取”属性或方法
- 对象拥有“"."的机制
- 方便数据的存取
如何封装

class User:
    x = 10
    def func():
        pass
obj = User()
obj.y = 20
obj ---> x, func, y

三、访问限制机制

什么是访问限制机制
- 凡是在类内部定义的属性或方法
- 以__开头的属性或方法名，都会被限制，外部不能”直接访问“该属性原型

注意：凡是再类内部定义__开头的属性或方法，都会变形为_类名__属性/方法

为什么要有访问限制
- 将一些隐私的数据，隐藏起来，不让外部轻易获取
- 接口
  - 可以将一堆数据封装成一个接口，可以让用户调用接口，并通过相应的逻辑，最后再将数据返回给用户
如何实现

class User:
    # __开头的属性
    __name = 'tank' # __name 变形为--> _类名__name

    # __开头的方法
    def __run(self):
        print('tank is running...')

print(User.__name) # 如果是这样，结果会报错

obj = User()
print(obj._User__name) # 这样就采用了 _类名__属性/方法，就可以打印成功
obj._User__run
# 结果
tank
tank is running

四、property

什么是property
- 是一个python内置的装饰器，可以装饰在"类内部的方法"上
- 可以将该方法的调用方式由 --->对象.方法() ---> 对象.方法

也就是可以不加括号的意思

为什么使用property
- 让名词的方法，调用时更为合理
- 迷惑调用者，调用的方法误以为是属性

# 需求：计算人体bmi指数
# 体重/ 身高的平方
class User:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    # 获取bmi指数方法
    @property
    def bmi(self):
        return self.weight / (self.height ** 2)

    @property
    def name(self):
        return self.__name

    # 设置被property装饰后的方法
    # 注意：需要修改的方法名字要与被property装饰器后的方法一样
    @name.setter
    def name(self, value):
        self.__name = value

    @name.deleter
    def name(self): # 删除属性
        del self.__name


user_obj = User('cxy', 65, 1.65)

# user_obj.bmi()
user_obj.bmi  # 使用property之后，就可以不加括号调用，加括号会报错

# 修改属性
# user_obj.name = 'yyy'
print(user_obj.name)

# # 删除属性
# del user_obj.name
print(user_obj.name)