面向对象——组合、封装、访问限制机制、property内置装饰器

面向对象——组合、封装、访问限制机制、property

组合

什么是组合？

组合指的是一个对象中，包含另一个或多个对象

为什么要组合？

减少代码的冗余

怎么用组合？

# 综合实现
# 父类
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_birth(self):
        print(f"""
        ========== 出生年月日 =========
            年：{self.year}
            月：{self.month}
            日：{self.day}
        """)

tea1 = Teacher('tank', 25, "男")
date_obj = Date(1994, 6, 6)
tea1.date_obj = date_obj
print(tea1.name, tea1.age, tea1.sex)
tea1.date_obj.tell_birth()

PS:继承是类与类的关系，子类继承父类的属性，是“从属关系”

​ 组合是对象与对象的关系，一个对象拥有另一个对象的属性和方法，是“什么有什么的关系”

封装

什么是封装？

封装指的是可以将一堆属性和方法，封装到对象中

PS:存不是目的，目的是为了取，可以通过 对象. 的方式获取属性和方法

为什么要封装？

为了更方便数据的存取

如何实现封装?

# 封装很简单
class User:
    # 将x封装到User类中
    x = 10
    # 将func方法封装到User类中
    def func(self):
        pass

obj = User
print(obj.x)

访问限制机制

什么是访问限制机制？

凡是在类内部定义的属性或方法，以__开头的名字，都会被限制，外部不能直接访问

PS：凡是在类内部定义的属性或方法，都会变形为_类名__属性/方法（python特有的）

class User:
    __name = "kang"

    def __run(self):
        print("kang is running....")

# print(User.__name)
obj = User()
print(obj._User__name)		# kang

为什么要有访问限制机制？

可以将一些隐私的数据，隐藏起来，不让外部轻易获取

class User:
    __name = "kang"
    __age = 18
    __sex = "男"
    __ID = 2156131316561316516131
    __bal = 1500000000000000000

    def parse_user(self, username, password):
        if username == "kang" and password == "123":
            print(f"""
            通过验证，获取用户信息
            用户名：{self.__name}
            用户年龄：{self.__age}
            用户性别：{self.__sex}
            用户ID：{self.__ID}
            用户资产：{self.__bal}
            """)
        else:
            print("校验失败，无法查询用户信息")

    def __run(self):
        print("kang is running....")

obj = User()
obj.parse_user("kang", "123")

property

什么是property？

property是一个python内置的装饰器，可以装饰在类内部的方法上

可以将该方法调用方式由 对象.方法() 转换为 对象.方法 (少了括号)

为什么用property？

在某些场景下，调用的方法只是用来获取计算后的某个值

必须通过 对象.方法() 方式调用，让该方法看起来像动词

目的是为了迷惑调用者，调用的方法误以为是属性，让名词的方法，调用时更加合理

怎么用？

class User:
    def __init__(self, name, weight, height):
        self.__name = name
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        return self.weight / (self.height ** 2)

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

    @name.setter
    def name(self, value):
        self.__name = value

    @name.deleter
    def name(self):
        del self.name

user_obj = User("kang", 50, 1.7)
print(user_obj.bmi)		# 这里user_obj.bmi后面应该有括号的，但是用了property就不用了