封装

什么是封装?

　　广义上(大家认为的):

　　　　把一类事物的相同的行为和属性归到一个类中

　　狭义上(学术上的定论)

　　　　把一些特殊的属性和方法藏在类中

　　　　外部无法调用,只有内部可以调用

 class Dog:
     dog_sum = 0
     def __init__(self):
         self.count()    # 从一个类的内部调用了count方法
     def count(self):
         Dog.dog_sum += 1

 alex = Dog()
 print(Dog.dog_sum)

 alex.count()            # # 从一个类的外部调用了count方法
 alex.count()
 alex.count()
 print(Dog.dog_sum)

隐藏静态属性class Dog:

 class Dog:
     # dog_sum = 0         # 不安全,因为这个属性可以在类的外部被随便修改
     __dog_sum = 0         # 安全,通过dog_sum方法和__变量名让属性变成只能看不能改的值
     def __init__(self):
         self.count()
     def count(self):
         Dog.__dog_sum += 1 # 可以从一个类的内部使用__dog_sum的属性
     def dog_sum(self):
         return Dog.__dog_sum

 print(Dog.__dict__)
 alex = Dog()
 print(Dog.__dict__)
 # print(Dog.__dog_sum)    # 不可以从外部直接使用这个变量
 print(alex.dog_sum())

 class Dog:
     __dog_sum = 0       # 私有的静态属性 _Dog__dog_sum
     def __init__(self):
         self.count()
     def dog_sum(self):
         return Dog.__dog_sum # 只要是在类的内部使用__名字,默认就被改成 _类名__名字

 print(Dog.__dict__)
 print(Dog._Dog__dog_sum)     # 绝不能在后续我们的代码中出现这种情况

 只要是在类的内部的名字前面加上双下划线
 那么这个名字 就变成 私有的 (只能在类的内部使用,不能在类的外部使用)
 在定义的时候,存储的名字就会发生变化 _类名__名字
 因此 在类的外部就不会被调用到了
 在类的内部 使用__名字,默认就被改成 _类名__名字

 class Dog:
     # dog_sum = 0         # 不安全,因为这个属性可以在类的外部被随便修改
     __dog_sum = 0         # 安全,通过dog_sum方法和__变量名让属性变成只能看不能改的值
     def __init__(self):
         self.__count()
     def __count(self):
         Dog.__dog_sum += 1 # 可以从一个类的内部使用__dog_sum的属性
     def dog_sum(self):
         return Dog.__dog_sum

 alex = Dog()
 print(alex.dog_sum())
 yuan = Dog()
 print(yuan.dog_sum())

　　

 class Dog:
     def __init__(self,name,password):
         self.__name = name           # 不希望某个值被随便修改
         self.__password = password   # 不希望某个值被从类的外部看到
     def login(self,usr,pwd):
         if usr == self.name and pwd == self.__password:
             return True
     def name(self):
         return self.__name
     def set_name(self,new_name):
         if type(new_name) is str:
             self.__name = new_name

 alex = Dog('alex','sb123')
 print(alex.login('alex','sb222'))
 print(alex.login('alex','sb123'))

 print(alex.name())
 alex.set_name('alex_sb')
 print(alex.name())

 只能在类的内部被调用,保证了类内部数据的安全,不会被别人随意修改

 私有静态属性  : 为了不随意被外部修改
 私有方法     :  不希望被外部随意调用
 私有的对象属性 :
      不希望某个值被随便修改
     不希望某个值被从类的外部看到

封装在继承中的情况

子类不能继承父类的私有方法

class Foo(object):
        __私有的静态变量 = "ABC"           #_Foo__私有的静态变量
        print("---->",__私有的静态变量)   #在类的内部使用 _Foo__私有的静态变量
class Son(Foo):
         pass

print(Foo.__私有的静态变量)  报错