面向对象------封装

Posted 2020-10-15

封装

定义

将自己想要隐藏起来的内容隐藏起来

原则

• 将不需要隐藏起来的内容隐藏起来

• 将属性隐藏起来，提供公共方法对其访问

私有属性：self.__属性名

私有方法：def __函数名（self）:

私有静态属性：__静态属性名

对象.__dict__ :查看自己的属性

class Teacher:
    __work = ‘jiangshi‘   #创建私有静态属性
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #创建自己的私有属性
    def __jiang(self): #创建自己私有方法
        print(self.__jiang)
shi = Teacher(‘jing‘,20)
print(shi.__dict__)    

class Student:
    def __init__(self,name,id):
        self.name = name
        self.__id = id #  私有属性创建
    def __learn(self):  # 私有方法创建
        print(self.__learn)
learn = Student(‘jing‘,2)
learn._Student__id = 6  #修改属性 id
print(learn.__dict__)

调用自己的私有属性、静态属性和方法加上（_类名）

私有方法还可以在类的内部使用

 

class Teacher:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd # 创建私有属性
    def __jiang(self):  #创建私有方法
        print(‘1‘)
jiang = Teacher(‘jing‘,123)
jiang._Teacher__jiang()  # 调用自己的私有方法 前加“_类名”
print(jiang._Teacher__pwd)
jiang._Teacher__pwd = 789 #调用修改私有属性  前加‘_类名’
print(jiang.__dict__)  #查看自己的属性

 

封装的应用场景

 

封装的好处

1. 提高安全性

2. 便于使用

父类的私有方法、静态属性、属性都只能在自己内部调用 ，不能在子类中调用

面向对象常用的装饰器

@property的作用

将一个类中的方法伪装成一个属性，调用时后面可以不用加括号

好处 ：

 

class Shop:
    discount = 
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property      #方法伪装成一个属性
    def price(self):
        return self.__price*self.discount  #私有属性*折
    @price.setter  #将方法伪装成属性修改
    def price(self,new_price):
        self.__price = new_price
apple =Shop(‘apple‘,10)
print(apple.price)   
apple.price = 5  #调用不用加括号
print(apple.price)

 

classmethod ：类的装饰器 将对象方法装饰成类方法必须传入一个参数（cls)

class A:
    @classmethod
    def func(cls):  #将对象的方法装饰成类的方法
        print(‘func‘)
A.func()

 

staticmethod: 静态方法装饰器，将对象方法装饰成静态方法

class A:
    @staticmethod
    def func():
        print(‘func‘)
A.func()

 

面向对象的封装方式 

public:其实就是不封装

private: 对谁都不公开 

类里共有三种定义方法：

1. 普通方法： self

2. 类方法 ：  cls   @classmethod

3. 静态方法：   @staticmethod