封装和内置函数property classmethod staticmethod

一.封装

1.封装的概念：

广义上的封装 : 属于一个类的静态和动态属性 总是出现在一个类中
              #使用永远在类的内部用类名或者对象名调用
狭义上的封装 : 就是把变量方法私有化,在类的外部以及子类中不能直接使用了

2.私有变量：

在python中用双下划线开头的方式将属性隐藏起来
在内部中调用会自动变形：__x都会自动变形成：_类名__x的形式

2.1静态变量私有化

class A:
    start="aaa"   # 静态变量
    __s="bbb"      # 私有的静态变量
    def wahaha(self):
        print(A.__s)  #A._A__s

1.在外部是无法通过__x这个名字找到变量
print(A.__s)  AttributeError
print(A._A__s) #bbb 在类的外面调用私有的变量 但不使用此方法
2.不能在外部创建一个私有的变量
A.__B="ccc"
print(A.__dict__) #在A中并没有_A_B:CCC

2.2属性私有化

class B:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd   # 也可以创建对象的私有属性
    def get_pwd(self):
        print(self.__pwd)
b = B('alex','alex3714')
print(b.name)  #alex
print(b.__pwd) AttributeError: 属性错误
print(b._B__pwd)  #alex3714

2.3方法私有化

class C:
    def __ppt(self):    # 私有的方法
        print('ppt')
        self.age = 83
    def open(self):
        self.__ppt()
        print('打开文件')
c = C()
c.open()
print(c.age)

总结：

私有的 静态变量 对象属性 方法：
    1.只能在类的内部定义和使用
    2.在类外部使用私有静态变量  _类名__私有的名字
    3.私有的名字 不能被子类继承

3.java

private 私有的  - __变量名
protect 保护的  - N/A（python中没有）
public 公共的   - 正常的变量

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

class A:
    def __fa(self): #在定义时就变形为_A__fa
        print('from A')
    def test(self):
        self.__fa() #只会与自己所在的类为准,即调用_A__fa
class B(A):
    def __fa(self):
        print('from B')
b=B()
b.test() #from A

二.内置函数property classmethod staticmethod

1.property ：将一个方法伪装成属性。在用时用对象属性的方式调用
2.classmethod:将一个普通方法装饰为一个类方法.操作都只能和类中的静态变量相关
3.staticmethod:将一个方法装饰成普通函数。在类中装饰一个不需要self参数 也不需要cls参数的函数

1.property

class Circle:
    def __init__(self,r):
        self.r=r
    @property
    def area(self):
        return self.r**2
    @property
    def prmite(self):
        return self.r*2
c=Circle(5)
print(c.area()) TypeError:此时area是属性
print(c.area)  #  25  用属性方法调用。不能用c.area

#####property属性和setter.delete合用###
class Person:
    def __init__(self,name):
        self.__name=name
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,new_name):
        if type(new_name)==str:
           self.__name=new_name
    @name.deleter
    def name(self):
        del self.__name
alex=Person("alex")
print(alex.name)
alex.name="alex_sb"
print(alex.name)
del alex.name
商品  价格 原价 打折 = 折后价
class Goods:
    def __init__(self,name,price,discount):
        self.name = name
        self.__price = price
        self.discount = discount
    @property
    def price(self):
        return self.__price * self.discount
apple = Goods('apple',5,0.8)
print(apple.price)

2.classmethod

类方法是被@classmethod装饰的特殊方法:
    1.被装饰之后,方法默认接收一个 类 作为参数
    2.之后所有的操作都只能和类中的静态变量相关 而不应该和对象相关
  3.类名 和 对象名 都可以直接调用类方法

class Goods:
    __discount = 0.8
    def  __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price*Goods.__discount
    @classmethod 
    def change_discount(cls,new_dis):  # 类方法
        cls.__discount = new_dis
Goods.change_discount(1)
cig = Goods('cigrette',20)
print(cig.price)
cig.change_discount(0.2)
print(cig.price)

3.staticmethod

class Student:
    def __init__(self,name):
        self.name = name
    @staticmethod    #装饰一个不需要self参数 也不需要cls参数的函数
    def login(a,b,c):    # 普通的函数
        usr = input('username>>>')
        pwd = input('password>>>')
        if usr == 'alex' and pwd == '123':
            obj = Student(usr)
            return obj
ret = Student.login(1,2,3)
print(ret)

房间类 : 所有人 价格 面积

class Room:
    def __init__(self,owner,price,length,width,height):
        self.owner = owner
        self.__price_single = price  #单价
        self.__length = length
        self.__width = width
        self.height = height
    def get_area(self):
        return self.__length * self.__width
    def get_price(self):
        return self.__price_single * self.get_area()
alex = Room('alex',1000000,2,1,0.8)
print(alex.get_area())
print(alex.get_price())