python 面向对象的三大特性之一: 封装

1. 封装的好处:

　　1. 将变化隔离

　　2. 便于使用

　　3. 提高复用性

　　4. 提高安全性

　　广义的封装: 实例化一个对象,给对象空间封装一些属性.

　　狭义的封装: 私有制.

　　私有成员:私有静态变量,私有方法,私有对象属性

　　私有静态变量:

　　　　实例化对象不能访问私有静态变量

　　　　类名不能访问私有静态变量

　　　　对于私有静态变量,类的外部不能访问

　　　　对于私有静态变量,类的内部都可以访问

　　　　子类(对象和类)不能访问父类的私有静态变量

　　私有方法:

　　　　类的内部可以访问

　　　　类外部不能访问

　　　　类的派生类(就是父类的方法)也不能访问

　　私有对象属性:

　　　　私有对象外部不能访问

　　　　私有对象在内部能够访问

1. 私有静态变量

class Myclass:
    __book = ‘书‘    # 类中的前面静态变量加了 ‘_ _‘就变成了私有静态变量

class MyAlipay(Myclass):
    __money = 200
    music = ‘音乐‘
    def pay(self):
        # 对于私有静态变量,类的内部都可以访问
        print(self.__money) # 在内部对象访问私有类
        print(self.music)
        print(MyAlipay.__money) # 在内部类名访问私有类

        # 对于私有静态变量,"类的|"外部不能访问
        # print(self.__book)  # 子类(对象和类)不能访问父类的私有静态变量
        # print(MyAlipay.__book)

m = MyAlipay()
print(m.music)

# print(m.__money)    # 在外部对象不能访问私有变量
# print(MyAlipay.__money)   # 在外部类名不能访问私有变量

m.pay()
# 对于私有静量字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.

2. 私有方法

class Myclass:
    __book = ‘书‘
    def __func(self):
        print(‘父类的私有方法‘)

class My(Myclass):
    sex = ‘不知‘
    def __func1(self):
        print(‘本类的私有方法‘)

    def func2(self):
        self.__func1()  # 在内部可以调用本类的私有方法
        self.__func() # 父类的私有方法,不可以调用

m = My()

# m.__func1() # 在类的外部不能调用
m.func2()   # 在类的内部可以调用,但是类的派生类(就是父类的方法)也不能调用

3. 私有对象属性

class Parent:

    def __init__(self,name,age):
        self.__name = name
        self.age = age

    def func(self):
        print(self.__name)

class Son(Parent):

    def func(self):
        print("in Son func")

    def func1(self):
        print(self.__name)

p1 = Parent("小王",12)
# print(p1.__name)    # 私有对象外部不能访问
p1.func()     # 私有对象在内部能够访问
print(p1.__dict__)
s1 = Son(‘小张‘,12)
# s1.func1()    # 不能访问父类的私有对象属性
# print(s1.__name)    # 不能访问父类的私有对象属性

原文地址：https://www.cnblogs.com/Pengdachui-1/p/11802251.html