面向对象中的成员

一、类的成员

class Foo:

    #方法
    def __init__(self,name):
        #实例变量/字段
        self.name = name

    #方法
    def func(self):
        pass
#obj，Foo类的对象
#obj，Foo类的实例
obj = Foo("Bob")

　　成员共分为三类：

　　　　变量：

　　　　　　实例变量(字段)

　　　　　　　　　　公有实例变量(字段)

　　　　　　　　　　私有实例变量(字段)

　　　　　　类变量(静态字段)　　#当所有对象中有共同的字段时且要改都改要删都删时，可以将实例变量(字段)提取到类变量(静态字段)

　　　　　　　　　　公有类变量(静态字段)

　　　　　　　　　　私有类变量(静态字段)

　　　　　　　　　　实例一：

　　　　　　　　　　　　　class Foo：

　　　　　　　　　　　　　　　　　　#类变量(静态字段)

　　　　　　　　　　　　　　　　　　country = "中国"

　　　　　　　　　　　　　　　　　　def __init__(self,name):

　　　　　　　　　　　　　　　　　　　　#实例变量(字段)

　　　　　　　　　　　　　　　　　　　　self,name = name

　　　　　　　　　　　　　　　　　　def func(self):

　　　　　　　　　　　　　　　　　　　　pass

　　　　　　　　　　　　　obj1 = Foo("阿萨德")

　　　　　　　　　　　　　obj2 = Foo("阿斯顿")

　　　　　　　　　　　　　Foo.country

　　　　　　　　如何验证子类知不知道私有字段的存在

#无法访问
class Base(object):
    __secret = "私有"
class Foo(Base):
    def func(self):
        print(self.__secret)
        print(Foo.__secret)
obj = Foo()
obj.func()

#可以访问
class Base(object):
    __secret = "私有"
    def fw(self):    #在Base内部访问了
        print(Base.__secret)
class Foo(Base):
    def func(self):
        print(self.__secret)
        print(Foo.__secret)
obj = Foo()
obj.fw()

　　　　方法：

　　　　　　1.实例方法：　　　　　　　　　

class Foo(object):
    def __init__(self,name):
        self.name = name
    #实例方法
    def func(self):
        print(self.name)
obj = Foo("asd")
obj.func()

　　　　　　2.静态方法：

class Foo(object):
    def __init__(self,name):
        self.name = name
    #静态方法，如果方法无需使用对象中封装的值，那么就可以使用静态方法
    @staticmethod
    def display(a1,a2):
        return a1+a2
Foo.display(1,4)

　　　　　　3.类方法

class Foo(object):
    #类方法,cls是类
    @classmethod
    def show(cls,x1,x2):
        print(cls,x1,x2)
#执行类方法
Foo.show("a","b")
#<class '__main__.Foo'> a b

　　　　属性：（通过方法改造出来）

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)

　　　　　　总结：

　　　　　　　　编写时：方法上方写@property

　　　　　　　　　　　　方法参数只有一个self

　　　　　　　　调用时：无需加括号 对象方法

　　　　　　　　应用场景：对于简单的方法，当无需传参且有返回值时