Python面向对象之封装

一、封装

　　封装就是指隐藏对象的属性和实现的细节，仅对外公开提供简单的接口。外部不能访问。内部可以正常使用

 

　　控制程序中属性的访问权限：Python中权限分为两种：

　　1：公开 外界可以直接访问和修改

　　2：私有 外界不能直接访问和修改，在当前类中可以直接修改和访问

 

　　封装的好处：

　　　　1、为了保护数据的安全 （身份证信息，银行卡密码等）

　　　　2、对外隐藏实现的细节，为了隔离复杂度  (电脑的开机功能等不需要考虑如何实现等)

 

　　封装的语法：

　　　　在属性名前添加两个下划线__ 将其设置为私有的

 

　　例子：

class Person:
    def __init__(self,name,age,id_number):
        self.__id_number=id_number          # 封装起来 变为私有
        self.age=age
        self.name=name

p = Person("1111111","aaa",20)
p.id_number="22222"
print(p.id_number)              #22222

 

二、外界访问私有内容

　　属性虽然被封装了，但是还是需要使用的，可以通过 定义类完成对私有属性对的修改和访问

class People:
    def __init__(self, name):
        self.__name = name
 
    def get_name(self):
        # 通过该接口就可以间接地访问到名字属性
        # print('不让看')
        print(self.__name)
 
    def set_name(self,val):
        if type(val) is not str:
            print('必须传字符串类型')
            return
        self.__name=val
 
# 使用者：aaa
obj = People('aaa')
#print(obj.name)             #此时会报错，因为name是隐藏属性。无法直接用名字属性
obj.get_name()               #访问name只能通过方法。此时结果为aaa

 

三、封装之property装饰器

　　作用：将一个方法伪装成普通的属性，其特殊之处在在于，该方法会在修改属性值时自动执行。用来绑定给对象的方法伪造成一个数据属性

　　例子:

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

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

    @name.setter                    #属性内置的，用于修改
    def name(self, val):           # obj1.name='aaa'
        if type(val) is not str:
            print('必须传入str类型')
            return
        self.__name = val

    @name.deleter                   #同上
    def name(self):                    # del obj1.name
        print('不让删除')
        # del self.__name


obj1 = People('aaa')
# 人正常的思维逻辑直接是对象.属性。然而事实上name属性是私有的，所以加上property就可以变为普通型，外界看着就是正常访问
print(obj1.name)             #aaa
obj1.name=18                 #必须传入str类型
del obj1.name                #不让删除

注意：name是被property装饰的方法的名称  也就是属性的名称内部会创建一个对象 变量名称就是函数名称，所以在使用setter和deleter时，必须保证使用的名称取调用方法.所以是name.setterh

 

　　2、property实现属性计算

class Square:
    def __init__(self,num):
        self.num=num
    @property             # 让属性装换为普通类 
    def area(self):
        return self.num*self.num
    
s=Square(10)
print(s.area)

#100

 

三、封装原理

　　就是在加载类的时候把__替换成了_类名_

#把fa定义成私有的，即__fa
class A:
   def __fa(self): #在定义时就变形为_A__fa
     print('from A')
   def test(self):
     self.__fa() #只会与自己所在的类为准,即调用_A__fa

class B(A):
   def __fa(self):
     print('from B')

b=B()
b.test()
#from A

 

四、接口

　　接口是一组功能的集合体，但是接口中仅包含功能的名字，不包含具体的实现代码;接口的本质是一套协议标准，遵循这个标准的对象就能被调用。接口的目的就就是为了提高扩展性

 

五、抽象类

　　指的是包含抽象方法（没有函数的方法）的类。可以实现强制性要求子类必须实现父类声明的方法。抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化,且有存在没有实现的方法

# 注意：不能直接实例化抽象类！！！

# 示例程序：

import abc  # 导入abc模块
class InMa(metaclass=abc.ABCMeta):  # 定义抽象方法
    @abc.abstractmethod  # 定义抽象方法
    def login(self):
        pass
    @abc.abstractmethod
    def zhuce(self):
        pass

class Login(InMa):  # 继承抽象类
    def __inti__(self, name, pwd):
        self.name = name
        self.password = pwd

    def login(self):  # 实现抽象方法功能
        if self.name == "qq" and self.password == "111":
            print("恭喜登录成功")
        else:
            print("登录失败")

class Zc(Login):

    def __init__(self, name, pwd):
        self.name = name

        self.password = pwd

    def zhuce(self):
        print("恭喜注册成功")

        print("username:", self.name)

        print("password:", self.password)


# 实例对象
ren = Zc("aaa", "bbb")

ren.zhuce()


'''
恭喜注册成功
username: aaa
password: bbb
'''