面向对象——封装

1.属性隐藏（私有）方法：双下划线"__"，是一种变形操作

• 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式
• 特点：
  • 类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果
  • 这种变形其实是针对外部的变形，在外部是无法通过__x这个名字访问到的
  • 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变成了：_子类名__x，而父类中变形成了：_父类名__x，即双下划线开头的属性在继承给子类时，子类时无法覆盖的。
• 注意：
  • 这种机制也并没有从真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__x
  • 变形过程只在类定义时发生一次，在定义后的赋值操作，不会变形

class A:
    __x = 1 #_A__x = 1
    def __init__(self,name):
        self.__name = name #self._A__name = name
    def __foo(self):
        print('run foo')
    def bar(self):
        self.__foo() # self._A__foo(),只有在类内部才可以通过__foo的形式访问到
        print('from bar')
# print(A.__dict__)
'''
{'__module__': '__main__', '_A__x': 1, 
'__init__': <function A.__init__ at 0x0000000001E25048>, 
'_A__foo': <function A.__foo at 0x0000000001E250D0>, 
'bar': <function A.bar at 0x0000000001E25400>, 
'__dict__': <attribute '__dict__' of 'A' objects>, 
'__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
'''
# print(A.__x)  #  报错
# print(A.__foo)#  报错
# print(A._A__x) #1

a = A('egon')
# a._A__foo()  #run foo
a.bar()# run foo   from bar

• 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况下：
class A:
    def fa(self):
        print('from A')
    def test(self):
        self.fa()
class B(A):
    def fa(self):
        print('from B')
b = B()
b.test()#from B,子类覆盖了父类的方法

#把fa定义成私有的，即__fa
class A:
    def __fa(self):
        print('from A')
    def test(self):
        self.__fa()
class B(A):
    def __fa(self):
        print('from B')
b = B()
b.test()#from A,隐藏后，子类不会覆盖父类的方法

2.封装

• 封装数据属性：明确的区分内外，控制外部对隐藏属性的操作行为

• class Teacher:
      def __init__(self,name,age):
          self.__name = name
          self.__age = age
      def tell_info(self):
          print('姓名：%s，年龄：%s'%(self.__name,self.__age))
      def edit_info(self,name,age):
          self.__name = name
          self.__age = age
  t = Teacher('egon',18)
  t.tell_info()#姓名：egon，年龄：18
  t.edit_info('egon',28)
  t.tell_info()#姓名：egon，年龄：28

• 封装方法：隔离复杂度

• '''
  #取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
  #对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
  #隔离了复杂度,同时也提升了安全性
  '''
  class ATM:
      def __card(self):
          print('插卡')
      def __auth(self):
          print('用户认证')
      def __input(self):
          print('输入取款金额')
      def __print_bill(self):
          print('打印账单')
      def __take_money(self):
          print('取款')
      def withdrwa(self):
          self.__card()
          self.__auth()
          self.__input()
          self.__print_bill()
          self.__take_money()
  a = ATM()
  a.withdrwa()
  '''
  插卡
  用户认证
  输入取款金额
  打印账单
  取款
  '''

• 扩展
  • 封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用者只知道一个接口（函数），只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑

• #扩展
  class Room:
      def __init__(self,name,owner,weight,length,height):
          self.name = name
          self.owner = owner
          self.__weight = weight
          self.__length = length
          self.__height = height
      def tell_area(self):
          return self.__weight * self.__length
  r = Room('教室','LuffyCity',10,10,3)
  print(r.tell_area())#100