面向对象编程中的封装与私有成员管理

在面向对象编程中，封装是将数据和操作绑定在一起，使程序更加易于维护和扩展。以下将从封装定义、作用、私有成员管理等方面对面向对象编程进行详细阐述。

一、封装定义

在面向对象编程中，封装是将数据和操作封装到类中，使得类不仅包含数据，还包含对数据的操作。通过封装，可以将复杂的逻辑隐藏起来，便于其他程序或用户使用。

二、作用

符合人类思维方式：类可以模拟现实世界中的对象，例如人物、车辆等，符合人类对世界的认知方式。

数据与操作结合：将数据和操作封装在一起，避免了数据的随意修改和操作的分散。

代码的复用性：通过封装，可以复用类的功能，减少代码冗余。

三、私有成员管理

在面向对象编程中，私有成员是指在类中定义的仅对类内部方法或属性可用的成员。私有成员可以通过以下方式实现：

基本概念及作用

私有成员的基本作用是将类的内部数据和操作隐藏起来，确保外部代码无法随意修改或访问。通过私有成员，可以保护类的数据和行为不受干扰。

使用__slots__实现私有成员

slots__是Python中用于限制类实例所能拥有的属性的一个特性。通过在类中定义__slots，可以指定实例只能具有特定的属性，防止不必要的属性占用内存。

使用@property和@propertysetter实现私有成员

@property和@propertysetter是Python中的装饰器，用于在类中定义只读属性和可写属性。通过这种方式，可以对类的属性进行更细粒度的控制。

四、基础示例代码

1. 使用方法封装变量

class Enemy:
    def __init__(self, name, atk, speed, hp):
        self.set_name(name)
        self.set_atk(atk)
        self.set_atk_speed(speed)
        self.set_hp(hp)
    
    def get_name(self):
        return self.__name
    
    def set_name(self, value):
        self.__name = value
    
    def get_atk(self):
        return self.__atk
    
    def set_atk(self, value):
        self.__atk = value
    
    def get_atk_speed(self):
        return self.__atk_speed
    
    def set_atk_speed(self, value):
        if 0 <= value <= 10:
            self.__atk_speed = value
        else:
            self.__atk_speed = 0
            print("速度不在范围内，赋值失败")
    
    def get_hp(self):
        return self.__hp
    
    def set_hp(self, value):
        if 0 <= value <= 100:
            self.__hp = value
        else:
            self.__hp = 0
            print("血量不在范围内，赋值失败")
e01 = Enemy("zs", 200, 50, 200)
print(e01.get_name(), e01.get_hp(), e01.get_atk_speed())

2. 使用属性封装变量

class Enemy:
    def __init__(self, name, atk, speed, hp):
        self.name = name
        self.atk = atk
        self.speed = speed
        self.hp = hp
    @property
    def name(self):
        return self.__name
    
    @name.setter
    def name(self, value):
        self.__name = value
    
    @property
    def atk(self):
        return self.__atk
    
    @atk.setter
    def atk(self, value):
        self.__atk = value
    
    @property
    def speed(self):
        return self.__speed
    
    @speed.setter
    def speed(self, value):
        self.__speed = value
    
    @property
    def hp(self):
        return self.__hp
    
    @hp.setter
    def hp(self, value):
        self.__hp = value
e01 = Enemy("zs", 200, 50, 200)
print(e01.name, e01.hp, e01.speed)

3. slots的使用

class SkillData:
    __slots__ = ("__name")
    def __init__(self, name):
        self.name = name
    
    @property
    def name(self):
        return self.__name
    
    @name.setter
    def name(self, value):
        self.__name = value
s01 = SkillData("技能名称")
s01.name = "降龙十八掌"
print(s01.name)
s01.time = 5
print(s01.time)
print(s01.__dict__)

五、实例练习

1. 练习1

class Person:
    def __init__(self, name):
        self.name = name
        self.__skills = []
        self.__total_money = 0
    
    @property
    def skills(self):
        return self.__skills[:]
    
    @property
    def total_money(self):
        return self.__total_money
    
    def teach(self, person_other, str_skill):
        person_other.__skills.append(str_skill)
        print(self.name, "教了", person_other.name, str_skill)
    
    def work(self, money):
        self.__total_money += money
        print(self.name, "工作挣了", money, "元")
zs = Person("张三")
ls = Person("李四")
zs.teach(ls, "python")
ls.teach(zs, "游戏")
zs.work(8000)
ls.work(4000)

2. 练习2

class SkillData:
    def __init__(self, name, cd, time, distance):
        self.name = name
        self.cd = cd
        self.time = time
        self.atk_distance = distance
    
    @property
    def name(self):
        return self.__name
    
    @name.setter
    def name(self, value):
        self.__name = value
    
    @property
    def cd(self):
        return self.__cd
    
    @cd.setter
    def cd(self, value):
        self.__cd = value
    
    @property
    def time(self):
        return self.__time
    
    @time.setter
    def time(self, value):
        self.__time = value
    
    @property
    def atk_distance(self):
        return self.__atk_distance
    
    @atk_distance.setter
    def atk_distance(self, value):
        self.__atk_distance = value
list_skills = [
    SkillData("降龙十八掌", 60, 10, 5),
    SkillData("如来神掌", 50, 5, 15),
    SkillData("六脉神剑", 80, 20, 8),
    SkillData("一阳指", 20, 50, 15),
    SkillData("冷酷追击", 15, 30, 9),
]
for item in list_skills:
    if item.name == "降龙十八掌":
        item.print_self()
result = []
for item in list_skills:
    if item.time > 10:
        result.append(item)
result = list_skills[0]
for i in range(1, len(list_skills)):
    if result.atk_distance < list_skills[i].atk_distance:
        result = list_skills[i]
result.print_self()
for r in range(len(list_skills) - 1):
    for c in range(r + 1, len(list_skills)):
        if list_skills[r].time > list_skills[c].time:
            list_skills[r], list_skills[c] = list_skills[c], list_skills[r]
print(list_skills)

3. 练习3

class Player:
    def __init__(self, hp, atk):
        self.atk = atk
        self.hp = hp
    
    def attack(self, enemy):
        print("打死你")
        enemy.damage(self.atk)
    
    def damage(self, value):
        self.hp -= value
        print("玩家受伤啦,屏幕碎啦")
        if self.hp <= 0:
            self.__death()
    
    def __death(self):
        print("玩家死亡,游戏结束")
class Enemy:
    def __init__(self, hp, atk):
        self.hp = hp
        self.atk = atk
    
    def damage(self, value):
        self.hp -= value
        print("受伤啦")
        if self.hp <= 0:
            self.__death()
    
    def attack(self, player):
        print("打死你")
        player.damage(self.atk)
    
    def __death(self):
        print("死啦,播放动画")
p01 = Player(100, 50)
e01 = Enemy(60, 10)
p01.attack(e01)
p01.attack(e01)
e01.attack(p01)

六、内存图

通过这些例子可以看出，面向对象编程通过封装和私有成员管理，使得类具有良好的封闭性和可扩展性。通过合理的私有成员设计，可以有效地保护类的数据和行为，不影响其他模块的正常运行。

转载地址：http://joofk.baihongyu.com/

你可能感兴趣的文章