面向对象的三大特性：继承　　多态　　封装

封装：（）

　　广义上的：

　　狭义上的：会为一种现象起一个专属它的名字

把函数和属性封装到一个非全局的命名空间

class A:

　　__N = 'aaa'　　静态变量

print(A.__N)

python

1.public

2.private

java（完全是面向对象的语言)

1.public

2.protect

3.private

定义一个私有的名字：就是在私有的名字面前加上双下划线 __N = 'aaa'

所谓私有就是不能再类的外面引用它

 class A:#     __N = 'aaa'  # 静态变量#     def func(self):#         print(A.__N)  # 在类的内部使用正常## a = A()# a.func()# print(A.__N) # 在类的外部直接使用 报错

class A:    __N = 'aaa'    def func(self):print(A.__N)

print(A.__dict__)print(A._A__N)

#{'func': <function A.func at 0x0000011B197637B8>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '_A__N': 'aaa', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'A' objects>}#aaa

# 一个私有的名字 在存储的过程中仍然会出现在A.__dict__中，所以我们仍然可以调用到。# python对其的名字进行了修改： _类名__名字# 只不过在类的外部调用 ：需要“_类名__名字”去使用# 在类的内部可以正常的使用名字

 _A__N# 在类内 只要你的代码遇到__名字，就会被python解释器自动的转换成_类名__名字

# 私有的名字，在类内使用的时候，就是会变形成_该类名__方法名# 以此为例 ：没有双下换线会先找E中的func# 但是有了双下划线，会在调用这个名字的类D中直接找_D__func

# 变形只在类的内部发生

# class D:
#     def __init__(self):
#         self.__func()
#     def __func(self):
#         print('in D')
#
# class E(D):
#     def __func(self):
#         print('in E')
# e = E()

# class F:pass# print(F.__dict__)# F.__name = 'aaa'# f = F()# print(f.__name)# print(F.__dict__)

# class F:pass
# print(F.__dict__)
# F.__name = 'aaa'
# f = F()
# print(f.__name)
# print(F.__dict__)
# class F:
#     def ADC(self):
#         self.__name = 'alex'
#
# f = F()
# f.ADC()
# print(F.__dict__)
# print(f.__dict__)

这个实例说明：在对象中创建的静态属性

Java中的对比：

public 共有的： 在类的内部可以使用，子类可以使用，在类的外部也可以使用　　python中所有正常的名字

protect 保护的：在类的内部可以使用，子类可以使用，在类的外部不可使用　　python中没有

private 私有的： 在类的内部可以使用，字类和在类的外部都不可使用。    python中的__名字

私有的用法：

　　当一个方法不想被子类继承的时候：

　　有些属性和方法不希望从外部调用，只希望从内部调用

# 人体BMI指数
# 体质指数（BMI）=体重（kg）÷身高^2（m）
# 写一个类 描述人体BMI指数class Person:def __init__(self,name,weight,height):self.name = nameself.__height = heightself.__weight = weight# self.bmi = self.__weight / self.__height ** 2# self.bmi = self.cal_BMI()def cal_BMI(self):return self.__weight / self.__height ** 2@propertydef bmi(self):return self.__weight / self.__height ** 2
p = Person('大表哥',92,1.85)

# print(p.cal_BMI())# p.cal_BMI()   # bmi是一个名词# print(p.bmi)   # bmi是一个名词# p._Person__weight = 90# print(p.bmi)

# 将一个方法伪装成一个属性 # 并不会让你的代码有什么逻辑上的提高 # 只是从调用者的角度上换了一种方式，使之看起来更合理

# @property 能够将一个方法伪装成一个属性# 从原来的的对象名.方法名()，变成了对象名.方法名# 只是让代码变的更美观

注意：如果出现了重名的名字：程序就会报错

# 将方法伪装成属性，方法中一般涉及的都是一些计算过程
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r = r
#     @property
#     def area(self):
#         return self.r**2*pi
#
#     @property
#     def perimeter(self):
#         return 2*pi*self.r
# c = Circle(10)
# print(c.area)
# print(c.perimeter)
# c.r = 15
# print(c.area)
# print(c.perimeter)

因为property不能传参，所有如果还想要将动态函数名改为名词性函数名，就需要用到名词性函数名.settle

 方法伪装成的属性的修改
# class Person:
#     def __init__(self,n):
#         self.__name = n  # 私有的属性了
#     @property
#     def name(self):
#         return self.__name
#
#     @name.setter        # 重要程度 ***
#     def name(self,new_name):
#         if type(new_name) is str:
#             self.__name = new_name
#         else:
#             print('您提供的姓名数据类型不合法')
#
# p = Person('alex')
# print(p.name)       #def name(self):
# p.name = 'alex_sb' #def name(self,new_name):
# print(p.name)       #def name(self):
# p.name = 123 #def name(self,new_name):
# print(p.name)       #def name(self):

# 方法伪装成的属性的删除class Person:def __init__(self,n):self.__name = n # 私有的属性了 @property # 重要程度 **** def name(self):return self.__name# @name.deleter # def name(self): # print('name 被删除了') # @name.deleter # 重要程度* # def name(self): # del self.__name

# p = Person('alex')# print(p.name)# del p.name # 只是执行了被@name.deleter装饰的函数# print(p.name)

#@property --> func 将方法伪装成属性，只观看的事儿#@func.setter --> func 对伪装的属性进行赋值的时候调用这个方法 一般情况下用来做修改#@func.deleter --> func 在执行del 对象.func的时候调用这个方法 一般情况下用来做删除 基本不用

# 商品的 折扣# 有一个商品 ： 原价 折扣# 当我要查看价格的时候 我想看折后价# class Goods:# def __init__(self,name,origin_price,discount):# self.name = name# self.__price = origin_price# self.__discount = discount## @property# def price(self):# return self.__price * self.__discount# @price.setter# def price(self,new_price):# if type(new_price) is int or type(new_price) is float:# self.__price = new_price# apple = Goods('apple',5,0.8)# print(apple.price)# # 修改苹果的原价# apple.price = 8# print(apple.price)

class Goods:    __discount = 0.8    def __init__(self,name,origin_price):self.name = nameself.__price = origin_price

@property def price(self):return self.__price * Goods.__discount

@classmethod def change_discount(cls,new_discount): # 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了 cls.__discount = new_discount

Goods.change_discount(1) # 不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量apple = Goods('apple',5)banana = Goods('banana',8)print(apple.price)print(banana.price)

# 折扣变了 店庆结束 恢复折扣# apple.change_discount(1) # 如果要改变折扣 是全场的事情 不牵扯到一个具体的物品 所以不应该使用对象来调用这个方法# print(apple.price)# print(banana.price)

# staticmethod# 当一个方法要使用对象的属性时 就是用普通的方法# 当一个方法要使用类中的静态属性时 就是用类方法# 当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法

# def login():# user= input('user :')# if user == 'alex':print('success')# else :print('faild')## login()class Student:def __init__(self,name):pass

 @staticmethod def login(a): # login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可 user = input('user :')if user == 'alex':print('success')else:print('faild')

Student.login(1)

# 完全面向对象编程# 先登录 后 实例化# 还没有一个具体的对象的时候 就要执行login方法

# 使用什么样的方法要看具体用到了哪些名称空间中的变量 # 当一个方法要使用对象的属性时 就是用普通的方法 # 当一个方法要使用类中的静态属性时 就是用类方法 # 当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法