面向对象--封装

封装

1、私有成员（将成员藏起来）

（1）作用：无需向类外提供的成员，可以通过私有化进行屏蔽
（2）做法：命名使用双下划线开头
（3）本质：障眼法，实际也可以访问（对象名._类名__成员名）
（4）作用域：仅在本类中有效

class Wife():
    def __init__(self, name, age, weight):
        self.__name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # __weight == _Wife__weight
        self.__age = age
        self.__weight = weight


wife01 = Wife("zs", 19 ,190)
wife01.weight = 1900  #创建了新的变量，并不能够访问私有变量
print(wife01.__dict__)
wife01._Wife__age = 100 #修改了类中定义的私有变量
print(wife01.__dict__)

如果想让外部类操作数据的话，可以由本类提供方法，进行设置数据和获取数据

class Wife():
    def __init__(self, name, age, weight):
        self.__name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # __weight == _Wife__weight
        self.__age = age
        self.__weight = weight

    def set_age(self, age):
        self.__age = age

    def get_age(self):
        return self.__age


w01 = Wife("zs", 19, 80)
w01.set_age(18)
print(w01.get_age())

可以通过set和get方法对数据的进行判断和设置

class Wife():
    def __init__(self, name, age, weight):
        self.__name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # __weight == _Wife__weight
        self.__age = age
        self.__weight = weight

# 提供公开的读写方法
    def set_age(self, age):
        if age < 20 and age > 40:
            self.__age = age
        else:
            print("age 不符合")

    def get_age(self):
        return self.__age


w01 = Wife("zs", 19, 80)
w01.set_age(40)
print(w01.get_age())

在构造方法中对私有变量进行了操作，所以构造方法对私有变量的操作也应该使用set和get方法

class Wife():
    def __init__(self, name, age):
        self.name = name
        # 本质：障眼法(实际将变量名改为：_类名__age)
        # __weight == _Wife__weight
        self.set_age(age)

# 提供公开的读写方法
    def set_age(self, age):
        if 20 > age > 40:
            self.__age = age
        else:
            print("age 不符合")

    def get_age(self):
        return self.__age


w01 = Wife("zs", 19)
w01.set_age(40)
print(w01.get_age())

但是这样写还是有弊端，因为set函数有可能是长度可变参函数，没办法看出来类有哪些成员，从而进行更改

2、property（读方法，写方法）对属性的读写进行拦截

class Wife(object):

    def __init__(self, age, name):
        self.age = age  # 通过变量间接调用set和get方法
        self.name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if 20 < age < 40:
            self.__age = age
        else:
            print("范围出错")

    age = property(get_age, set_age)


wife01 = Wife(29, "zs")
print(wife01.age)

达到的效果，通过类变量指向property方法，实现对属性的拦截，直接用对象名.属性名就可以使用私有变量了，提供了方便

class Enemy:
    def __init__(self, name, hp, atk):
        self.name = name
        self.hp = hp
        self.atk = atk

    def get_atk(self):
        return self.__atk

    def set_atk(self, atk):
        if 10 <= atk <= 50:
            self.__atk = atk
        else:
            print("攻击力设置不可理")

    atk = property(get_atk, set_atk)

    def get_hp(self):
        return self.__hp

    def set_hp(self, hp):
        if 100 <= hp <= 200:
            self.__hp = hp
        else:
            print("血条设置不合理")

    hp = property(get_hp, set_hp)


e01 = Enemy("灭霸", 100)

set_hp 相当于是回调函数

 hp = property(None, set_hp)
 

将读方法置为空，表示不能进行读取

3、常用写法

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

    @property  # 创建property对象，只负责拦截读取操作
    def age(self):
        return self.__age

    @age.setter  # 只负责拦截写入操作
    def age(self, age):
        if 0 < age < 10:
            self.__age = age
        else:
            print("设置不合理")

    @property
    def weight(self):
        return  self.__weight

    @weight.setter
    def weight(self, value):
        self.__weight = value

原理和2的一模一样，只不过是写法更高级罢了