面向对象:类的成员

类的成员(3种): 变量, 方法, 属性
1. 变量(2种):实例变量, 类变量

class Foo:
    country = "中国"         #类变量(静态字段)
    def __init__(self,name): #实例变量(字段)
        self.name = name
    def func(self):
        pass

obj1 = Foo("季红")
obj2 = Foo("王小二")
print(obj1.name)
print(Foo.country)

准则: 实例变量(字段)访问的时候用对象访问, 例如:obj.name
    类变量(静态字段)访问的时候用类访问, 例如:Foo.country

# 知识点一:易错点
"""
obj1 = Foo('季红')
obj2 = Foo('王晓东')

# 练习1
# obj1.name = 'alex'
# print(obj1.name) # alex
# print(obj2.name) # 王晓东

# 练习2
# obj1.country = '美国'
# print(obj1.country) # 美国
# print(obj2.country) # 中国

# 练习3
# Foo.country = '美国'
# print(obj1.country) # 美国
# print(obj2.country) # 美国

什么时候用类变量?
当所有对象中有共同实例变量(字段)的时候,并且这些变量要改都改,要删都得删的时候,可将实例变量(字段)提取到类变量(静态字段)

实例变量: 公有变量和私有变量
类变量: 公有变量和私有变量

# --------------公有实例变量 -----------
class Foo:
    def __init__(self, name):
        self.name = name
        self.age = 23

    def func(self):
        print(self.name)

obj = Foo("alex")
print(obj.name) #alex
print(obj.age)  #23
obj.func() #alex

# ------------私有实例变量 -----------------
class Foo:
    def __init__(self, name):
        self.__name = name
        self.age = 23
    def func(self):
        print(self.__name)

obj = Foo("alex")
# print(obj.name)  # 访问不到了, 可以通过func 访问到
print(obj.age)  # 23
obj.func()  # alex

# ----------------公有类变量--------------
class Foo:
    country = "中国"
    def __init__(self):
        pass
    def func(self):
        #内部调用
        # print(self.country)
        print(Foo.country) # 推荐
        # pass
#外部调用
print("外部调用",Foo.country)
obj = Foo()
obj.func()

# ----------------私有类变量--------------
class Foo:
    __country = "中国"
    def __init__(self):
        pass
    def func(self):
        #内部调用
        # print(self.__country)
        print("内部调用", Foo.__country) # 推荐
        # pass

#外部无法调用 **********************
# print("外部调用",Foo.country)
obj = Foo()
obj.func()

2. 方法: 实例方法, 静态方法, 类方法

# 实例方法
class Foo(object):
    def __init__(self,name):
        self.name = name
    def func(self): # 直接打印,没有用到已经封装的值,没必要写实例方法
        print("233333")
obj = Foo("alex")
obj.func()



class Foo(object):
    def __init__(self,name):
        self.name = name

    #实例方法
    def func(self):
        print(self.name)
obj = Foo("alex")
obj.func()



# 静态方法
class Foo(object):
    def __init__(self, name):
        self.name = name

    #实例方法
    def func(self):
        print(self.name)

    # 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    @staticmethod
    def display(a1, a2):
        return a1 + a2

obj = Foo("123")
obj.func()
print(obj.display(2,4))
ret = Foo.display(1,3)
print(ret)
# 总结: 编写时:
#        方法上方写@staticmethod
#        方法参数可有可无
#       调用时:
#         类.方法名() #推荐
#         对象.方法名()
#       什么时候用静态方法?
#           无需调用对象中已经封装的值


# 类方法
class Foo(object):
    def __init__(self,name):
        self.name = name

    #实例方法,self是对象
    def func(self):
        print(self.name)

    #静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    @staticmethod
    def display(a1,a2):
        return a1 + a2

    #类方法, cls是类
    @classmethod
    def show(cls,x1,x2):
        return x1 + x2

#执行类方法
ret = Foo.show(3,4)
print(ret)

#总结:
#   定义时:
#         方法上方写: @classmethod
#         方法的参数: 至少有一个cls参数
#   执行时:
#       类名.方法名() #默认会从当前类传到参数中
#   什么时候用?
#       如果在方法中会使用到当前类,那么就可以使用类方法

实例方法: 公有变量 和 私有变量

静态方法: 公有变量 和 私有变量

类方法: 公有变量 和 私有变量

# ------------私有的实例方法--------------
class Foo(object):

    def __init__(self):
        pass
    def __display(self,arg):
        print("私有方法",arg)

    def func(self):
        self.__display(123)

obj = Foo()
# obj.__display(123) #无法访问
obj.func()

# ------------私有的静态方法--------------

class Foo(object):

    def __init__(self):
        pass

    @staticmethod
    def __display(arg):
        print("私有静态方法",arg)

    def func(self):
        self.__display(123)

    @staticmethod
    def get_display():
        Foo.__display(88888) # 类.方法名() 调用静态方法

# Foo.__display(123) #报错
obj = Foo()
obj.func()
Foo.get_display()

3. 属性

# 属性(通过方法改造出来)

class Foo(object):
    def __init__(self):
        pass

    @property
    def start(self):
        return 1

    @property
    def end(self):
        return 10
obj = Foo()
print(obj.start)
print(obj.end)

#总结:
#   1.编写时:
#         方法上写 @property
#         方法参数: 只有一个self
# 2.调用时: 无需加括号   对象.方法
# 3.应用场景: 对于简单的方法,当无需传参且有返回值时,可以使用 @property