面向对象 - 封装/property

面向对象 - 封装：
    封装：在类定义阶段，以__开头的属性名发生了变形 eg:  __x --> _A__x / __foo --> _A__foo
    1.特点：
        1.在类外部无法直接访问   __x 是 _A__x
        2.在类内部可以直接使用   self.__foo() == self._A__foo()
        3.子类无法覆盖父类以__开头的属性 因为根本不是一个名字 __x  _A__x
    2.总结：
        这种变形需要注意的问题：
            1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，
              如a._A__N  eg:print(A._A__x) 但一般不这样做！
            2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形   eg: b.__age=18  {'_B__name': 'alice', '__age': 18}
            3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的  eg: def __foo(self):  #_A__foo
    3.意义：
        1.封装数据属性的目的：（封装不是单纯意义上的隐藏）
            明确的区分内外，控制外部对隐藏属性的操作行为  对接口 设定规则
        2.封装方法属性的目的：
            隔离复杂度  a=ATM() a.withdraw()  对接口 设定规则
    4.扩展性：
        def tell_area(self) 对使用者来说不用改变方式 开发者在类里面扩展
        面向对象的三大特征：继承 多态 封装
        面向对象的优点：可扩展性高

 class A:

     __x=1

     def __init__(self,name):

         self.name=name

     def __foo(self):

         print('run foo')

     def bar(self):

         self.__foo()

         print('run bar')

 a=A('alice')

 # print(a.__dict__)

 # print(a.name)

 # a.bar()

 # # a.foo()

 # a._A__foo()

 # # print(a.__x)

 # print(a._A__x)

 # print(A.__dict__)

 # a.bar()

 # a.__foo()

 # a.__x=1

 # print(a.__dict__)

 # print(a.__x)

 # print(A.__dict__)

 # A.__x=2

 # print(A.__x)

 # print(A.__dict__)

 class Foo:

     def __func(self):

         print('from foo')

 class Bar(Foo):

     def __init__(self,name):

         self.__name=name

     def __func(self):

         print('from bar')

 # b=Bar()

 # # b.func()

 # print(Foo.__dict__)

 # print(Bar.__dict__)

 b=Bar('alice')

 # print(b.__dict__)

 # print(b.name)

 # print(b._Bar__name)

 class A:

     def __foo(self): #_A__foo

         print('A.foo')

     def bar(self):

         print('A.bar')

         self.__foo()  #self._A__foo()  # 只调自己类的方法 定义时就已经确定好的！

 class B(A):

     def __foo(self): # _B_fooo

         print('B.foo')

 # b=B()

 # b.bar()

 # print(A.__dict__)

 # print(B.__dict__)

 class People:

     def __init__(self,name,age):

         self.__name=name

         self.__age=age

     def tell_info(self):   #对接口 设定规则

         print('name:<%s> age:<%s>'%(self.__name,self.__age))

     def set_info(self,name,age):

         if not isinstance(name,str):

             print('名字必须是字符串类型')

             return

         if not isinstance(age,int):

             print('年龄必须是数字类型')

             return

         self.__name=name

         self.__age=age

 p1=People('alice',12)

 # print(p1.name,p1.age)

 # print(p1.__dict__)

 # p1.tell_info()

 # p1.set_info('alex',18)

 # p1.tell_info()

 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 withdraw(self):

         self.__card()

         self.__auth()

         self.__input()

         self.__print_bill()

         self.__take_money()

 # a=ATM()

 # a.withdraw()

 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 * self.__height

 r=Room('客厅','alice',100,100,100)

 # print(r.tell_area())

封装

面向对象 - property： 
    property:
        1.@property 将函数属性 伪装成 数据属性
        2.必须要有返回值 return ''
        3.@property     查看 必须要有返回值   print(p.name)  name 是函数属性 不是数据属性 伪装成 数据属性
          @name.setter  修改                 p.name='alex'
          @name.deleter 删除                 del p.name
    总结：通过计算得来的方法 可以通过@property 伪装成数据属性

 class People:

     def __init__(self,name,weight,height):

         self.name=name

         self.weight=weight

         self.height=height

     @property

     def bmi(self):

         return self.weight / (self.height ** 2)

 p = People('alice',60,1.65)

 # print(p.bmi())

 # print(p.bmi)

 # p.bmi=12

 class People:

     def __init__(self,name):

         self.__name=name

     @property

     def name(self):

         return self.__name

     @name.setter

     def name(self,val):

         if not isinstance(val,str):

             print('名字必须是str')

             return

         self.__name=val

     @name.deleter

     def name(self):

         print('不允许删除')

 p=People('alice')

 print(p.name)

 p.name='alex'

 print(p.name)

 del p.name

property

巴特西

面向对象 - 封装/property - 总结

最新文章

热门文章