# 广义上的封装
# class 类名：
# def 方法名(self):pass
# 是为了只有这个类的对象才胡使用定义在类中的方法
# 狭义上的封装： 把一个名字藏在类中
class Goods:
__discount = 0.2 # 私有的静态变量
print(__discount) # 0.2
# 在类的外部不能引用私有的静态变量
# 类中的静态变量和方法名，在程序加载 的过程 中，已经执行完了，不需要等待调用
# 在这个类加载完成 之前，Goods这个类名，还没见有出现在全局名称空间中
# 私有的静态变量可以在类的内部使用，用来隐藏某个变量的值。
print(Goods.__dict__) # {'__module__': '__main__', '_Goods__discount': 0.2, '__dict__': <attri
class Goods:
__discount = 0.7 # 私有的静态变量
# 变形： _类名__私有变量
# print(Goods.__discount) # AttributeError: type object 'Goods' has no attribute '__discount' 类对象没有这个属性
print(Goods._Goods__discount) # 这样可以从类的外部访问，但是从编程规范的角度上出发，不建议在类的外部
# 使用私有的静态变量
class Student:
def __init__(self,name,age):
self.__name = name # 对象的私有变量，类外部，不能操作
self.age = age
def getName(self):
return self.__name
student = Student("王小宝",28)
# print(student.__name) # 报错，对象没有这个属性
print(student.getName()) # 王小宝 这是通过类中的方法，来操作对象的私有变量
print(student.__dict__) # {'_Student__name': '王小宝', 'age': 28} 对象的属性，是存在对象的名称空间中的，并且对于
# 对象的私有变量，也作了一个变形，以对象所属的直接类 _类名__私有变量
print(student.age)
student.age = "aaaa" # python是弱类型 语言
print(student.age)
class Goods:
__discount = 0.6 # 私有的静态变量
def __init__(self,name,price):
self.name = name
self.__price = price # 我不想让你看到这个值
def getPrice(self):
return self.__price * self.__discount
def changePrice(self,newPrice): # 我想让你修改一个值的时候有一些限制
if type(newPrice) is int:
self.__price = newPrice
else:
print("本次价格修改不成功")
pear = Goods("pear",89)
print(pear.getPrice()) # 53.4
pear.changePrice(100) # 将价格改为100
print(pear.getPrice()) # 60.0
class User:
def __init__(self,username,password):
self.username = username
self.__pwd = password
self.pwd = self.__getpwd()
def __getpwd(self):
return hash(self.__pwd)
user = User("chirs",'jiayong')
print(user.pwd) # -4615835297725458545
# 类中的私有成员
# 私有的静态变量
# 私有的对象变量
# 私有的方法
# 私有的变量，在内存中存储时 会 变形，在使用时，也会变形
# 为什么要定义一 个私有变量呢？
# 不想让你看到这个变量
# 不想让你修改这个变量
# 想让你修改这个变量有一些限制
# 有些方法或属性不希望被子类继承
#
# 广义上的封装，把属性和函数都放到类里
# 狭义上的封装，定义 私有成员
# 私有变量能不能 在类的外部 定义 ？？？？
class A:
__private = 1000
print(__private)
def getAge(self):
print(self.__age)
print(A.__dict__) # {'__module__': '__main__', '_A__private': 1000, '__dict__': <attrib
print(A._A__private) # 1000
A.__language = "chinese"
print(A.__dict__)
A._A__age = 18 # 通过 这种方式，可以在外部定义一个私有的静态属性
print(A.__dict__)
print(A._A__age) # 18
A.getAge(A) # 18
# 私有变量能不能被继承？？？
class A:
age = 100
__country = "china"
def __init__(self,name):
self.__name = name # 存储时 变形 _A__name
class B(A):
# print(age) # NameError: name 'age' is not defined
# print(__country)
def getName(self):
return self.__name # _B__name
b = B("jeason")
print(b.__dict__)
# b.getName() # AttributeError: 'B' object has no attribute '_B__name'
# 结论： 对于 类中的私有变量 ，在那个类中，变量时，就是那个类的名字 和 下划线打头 ： _类名__私有变量
