初识面向对象-封装、property装饰器、staticmathod（静态的方法）、classmethod（类方法） （五）

封装

# class Room:
#     def __init__(self,name,length,width):
#         self.__name = name
#         self.__length = length
#         self.__width = width
#     def get_name(self):#C++的编码习惯，一个get和一个set
#         return self.__name
#     def set_name(self,newName):
#         if type(newName) is str and newName.isdigit() == False:
#             self.__name = newName
#         else:
#             print('不合法的姓名')
#     def area(self):
#         return self.__length * self.__width
#
# jin = Room('金老板',2,1)
# print(jin.area())
# jin.set_name('2')
# print(jin.get_name())

# 假设父类的私有属性 能被 子类调用么
# class Foo:
#     __key = '123'       # _Foo__key
#
# class Son(Foo):
#     print(Foo.__key)     # _Son__key


# 会用到私有的这个概念de场景
#1.隐藏起一个属性 不想让类的外部调用
#2.我想保护这个属性，不想让属性随意被改变
#3.我想保护这个属性，不被子类继承

property

# property
# 内置装饰器函数 只在面向对象中使用
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property（加装饰伪装成一个属性，后面直接连方法名即可，类似查看属性）
    def perimeter(self):
        return 2*pi*self.r
    @property
    def area(self):
        return self.r**2*pi

# c1 = Circle(5)
# print(c1.area)     # 圆的面积，面积和周长是一个名字，相当一个属性，所以我把他伪装成一个属性，看上去更合理，但不能像其他属性那样去外部更改，因为它是计算而得的
# print(c1.perimeter) # 圆的周长

# class Person:
#     def __init__(self,name,high,weight):
#         self.name = name
#         self.high = high
#         self.weight = weight
#     @property
#     def bmi(self):
#         return self.weight / self.high**2

# jin = Person('金老板',1.6,90)
# jin.bmi = 18
# classmethod
# staticmethod

# class Person:
#     def __init__(self,name):
#         self.__name = name
#     @property
#     def name(self):
#         return self.__name + 'sb'
#     @name.setter
#     def name(self,new_name):
#         self.__name = new_name
#
# tiger = Person('泰哥')
# print(tiger.name)
# tiger.name = '全班'#像要修改伪属性，要在上面加 @name.setter一段代码
，三个标红name必须一样


# print(tiger.name)

# 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
# apple = Goods('苹果',5)
# print(apple.price)

# 属性 查看 修改 删除
# class Person:
#     def __init__(self,name):
#         self.__name = name
#         self.price = 20
#     @property
#     def name(self):
#         return self.__name
#     @name.deleter
#     def name(self):
#         del self.__name
#     @name.setter
#     def name(self,new_name):
#         self.__name = new_name
# brother2 = Person('二哥')
# del Person.price 
# #brother2.name = 'newName'
# #brother2
# del brother2.name #deleter以及下方内容不会有删除的作用，当外部用del Person.price就会触发找到@name.deleter，然后执行下方函数的删除私有属性

动作



# print(brother2.name)#这里的不是删除name方法名，而是去执行删除属性的方法，对象是没权删除类里的方法的

class_static

# method 方法
# staticmathod  静态的方法 ***
# classmethod   类方法    ****
# 类的操作行为
# 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_discount):  # 修改折扣
#         cls.__discount = new_discount
# apple = Goods('苹果',5)
# print(apple.price)
# Goods.change_discount(0.5)   # Goods.change_discount(Goods)
# print(apple.price)
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

# java
class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()
# 在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

# 类方法和静态方法 都是类调用的
# 对象可以调用类方法和静态方法么？   可以   一般情况下 推荐用类名调用
# 类方法 有一个默认参数 cls 代表这个类  cls
# 静态方法 没有默认的参数 就象函数一样

 下周内容
 # 面向对象的进阶
 # 网络编程