精华内容
下载资源
问答
  • Python 实例方法、类方法和静态方法

    万次阅读 多人点赞 2018-03-30 20:17:19
    在 Python 中,实例方法(instance method),类方法(class method)与静态方法(static method)经常容易混淆。本文通过代码例子来说明它们的区别。 实例方法 Python 的实例方法用得最多,也最常见。我们先来...

    在 Python 中,实例方法(instance method),类方法(class method)与静态方法(static method)经常容易混淆。本文通过代码例子来说明它们的区别。

    实例方法

    Python 的实例方法用得最多,也最常见。我们先来看 Python 的实例方法。

    class Kls(object):
        def __init__(self, data):
            self.data = data
    
        def printd(self):
            print(self.data)
    
    
    ik1 = Kls('leo')
    ik2 = Kls('lee')
    
    ik1.printd()
    ik2.printd()

    输出:

    leo
    lee

    上述例子中,printd为一个实例方法。实例方法第一个参数为self,当使用ik1.printd()调用实例方法时,实例ik1会传递给self参数,这样self参数就可以引用当前正在调用实例方法的实例。利用实例方法的这个特性,上述代码正确输出了两个实例的成员数据。

    类方法

    Python 的类方法采用装饰器@classmethod来定义,我们直接看例子。

    class Kls(object):
        num_inst = 0
    
        def __init__(self):
            Kls.num_inst = Kls.num_inst + 1
    
        @classmethod
        def get_no_of_instance(cls):
            return cls.num_inst
    
    
    ik1 = Kls()
    ik2 = Kls()
    
    print ik1.get_no_of_instance()
    print Kls.get_no_of_instance()

    输出:

    2
    2

    在上述例子中,我们需要统计类Kls实例的个数,因此定义了一个类变量num_inst来存放实例个数。通过装饰器@classmethod的使用,方法get_no_of_instance被定义成一个类方法。在调用类方法时,Python 会将类(class Kls)传递给cls,这样在get_no_of_instance内部就可以引用类变量num_inst
    由于在调用类方法时,只需要将类型本身传递给类方法,因此,既可以通过类也可以通过实例来调用类方法。

    静态方法

    在开发中,我们常常需要定义一些方法,这些方法跟类有关,但在实现时并不需要引用类或者实例,例如,设置环境变量,修改另一个类的变量,等。这个时候,我们可以使用静态方法。
    Python 使用装饰器@staticmethod来定义一个静态方法。

    IND = 'ON'
    
    
    class Kls(object):
        def __init__(self, data):
            self.data = data
    
        @staticmethod
        def checkind():
            return IND == 'ON'
    
        def do_reset(self):
            if self.checkind():
                print('Reset done for: %s' % self.data)
    
        def set_db(self):
            if self.checkind():
                print('DB connection made for: %s' % self.data)
    
    
    ik1 = Kls(24)
    ik1.do_reset()
    ik1.set_db()

    输出:

    Reset done for: 24
    DB connection made for: 24

    在代码中,我们定义了一个全局变量IND,由于IND跟类Kls相关,所以我们将方法checkind放置在类Kls中定义。方法checkind只需检查IND的值,而不需要引用类或者实例,因此,我们将方法checkind定义为静态方法。
    对于静态方法,Python 并不需要传递类或者实例,因此,既可以使用类也可以使用实例来调用静态方法。

    实例方法,类方法与静态方法的区别

    我们用代码说明实例方法,类方法,静态方法的区别。注意下述代码中方法fooclass_foostatic_foo的定义以及使用。

    class Kls(object):
        def foo(self, x):
            print('executing foo(%s,%s)' % (self, x))
    
        @classmethod
        def class_foo(cls,x):
            print('executing class_foo(%s,%s)' % (cls,x))
    
        @staticmethod
        def static_foo(x):
            print('executing static_foo(%s)' % x)
    
    
    ik = Kls()
    
    # 实例方法
    ik.foo(1)
    print(ik.foo)
    print('==========================================')
    
    # 类方法
    ik.class_foo(1)
    Kls.class_foo(1)
    print(ik.class_foo)
    print('==========================================')
    
    # 静态方法
    ik.static_foo(1)
    Kls.static_foo('hi')
    print(ik.static_foo)

    输出:

    executing foo(<__main__.Kls object at 0x0551E190>,1)
    <bound method Kls.foo of <__main__.Kls object at 0x0551E190>>
    ==========================================
    executing class_foo(<class '__main__.Kls'>,1)
    executing class_foo(<class '__main__.Kls'>,1)
    <bound method type.class_foo of <class '__main__.Kls'>>
    ==========================================
    executing static_foo(1)
    executing static_foo(hi)
    <function static_foo at 0x055238B0>

    对于实例方法,调用时会把实例ik作为第一个参数传递给self参数。因此,调用ik.foo(1)时输出了实例ik的地址。

    对于类方法,调用时会把类Kls作为第一个参数传递给cls参数。因此,调用ik.class_foo(1)时输出了Kls类型信息。
    前面提到,可以通过类也可以通过实例来调用类方法,在上述代码中,我们再一次进行了验证。

    对于静态方法,调用时并不需要传递类或者实例。其实,静态方法很像我们在类外定义的函数,只不过静态方法可以通过类或者实例来调用而已。

    值得注意的是,在上述例子中,foo只是个函数,但当调用ik.foo的时候我们得到的是一个已经跟实例ik绑定的函数。调用foo时需要两个参数,但调用ik.foo时只需要一个参数。fooik进行了绑定,因此,当我们打印ik.foo时,会看到以下输出:

    <bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

    当调用ik.class_foo时,由于class_foo是类方法,因此,class_fooKls进行了绑定(而不是跟ik绑定)。当我们打印ik.class_foo时,输出:

    <bound method type.class_foo of <class '__main__.Kls'>>

    当调用ik.static_foo时,静态方法并不会与类或者实例绑定,因此,打印ik.static_foo(或者Kls.static_foo)时输出:

    <function static_foo at 0x055238B0>

    概括来说,是否与类或者实例进行绑定,这就是实例方法,类方法,静态方法的区别。

    参考资料

    1. https://www.pythoncentral.io/difference-between-staticmethod-and-classmethod-in-python/
    2. https://taizilongxu.gitbooks.io/stackoverflow-about-python/content/14/README.html
    3. https://kuanghy.github.io/2015/12/19/python-variable
    4. https://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python
    展开全文
  • python类的实例方法、静态方法和类方法区别及其应用场景 一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。 ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一...

    python类的实例方法、静态方法和类方法区别及其应用场景

    一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。

     

    ps.python中self,cls的区别

    普通实例方法,第一个参数需要是self,它表示一个具体的实例本身。
    如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用。
    而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身。

    # coding:utf-8
    class Foo(object):
        """类三种方法语法形式"""
    
        def instance_method(self):
            print("是类{}的实例方法,只能被实例对象调用".format(Foo))
    
        @staticmethod
        def static_method():
            print("是静态方法")
    
        @classmethod
        def class_method(cls):
            print("是类方法")
    
    foo = Foo()
    foo.instance_method()
    foo.static_method()
    foo.class_method()
    print('----------------')
    Foo.static_method()
    Foo.class_method()

    运行结果如下

    是类<class '__main__.Foo'>的实例方法,只能被实例对象调用
    是静态方法
    是类方法
    ----------------
    是静态方法
    是类方法

    说明:

    实例方法只能被实例对象调用,静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法),可以被类或类的实例对象调用。

    实例方法,第一个参数必须要默认传实例对象,一般习惯用self。
    静态方法,参数没有要求。

    类方法,第一个参数必须要默认传类,一般习惯用cls。

    二、静态方法、类方法使用区别或者说使用场景

     

    1、类方法用在模拟java定义多个构造函数的情况。

     由于python类中只能有一个初始化方法,不能按照不同的情况初始化类。

    参考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 请看下面的代码。

    # coding:utf-8
    class Book(object):
    
        def __init__(self, title):
            self.title = title
    
        @classmethod
        def class_method_create(cls, title):
            book = cls(title=title)
            return book
    
        @staticmethod
        def static_method_create(title):
            book= Book(title)
            return book
    
    book1 = Book("use instance_method_create book instance")
    book2 = Book.class_method_create("use class_method_create book instance")
    book3 = Book.static_method_create("use static_method_create book instance")
    print(book1.title)
    print(book2.title)
    print(book3.title)

    结果:

    use instance_method_create book instance
    use class_method_create book instance
    use static_method_create book instance
    
    Process finished with exit code 0

    特别说明,静态方法也可以实现上面功能,当静态方法每次都要写上类的名字,不方便。

    2、类中静态方法方法调用静态方法和类方法调用静态方法例子。
    下面的代码,静态方法调用另一个静态方法,如果改用类方法调用静态方法,可以让cls代替类,

    让代码看起来精简一些。也防止类名修改了,不用在类定义中修改原来的类名。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 2
    
        @staticmethod
        def averag(*mixes):
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # 在静态方法中调用静态方法
            print "在静态方法中调用静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 在类方法中使用静态方法
            print "在类方法中使用静态方法"
            return cls.averag(cls.X, cls.Y)
    
    foo = Foo()
    print(foo.static_method())
    print(foo.class_method())

    结果:

    在静态方法中调用静态方法
    1
    在类方法中使用静态方法
    1

    3、继承类中的区别 

    从下面代码可以看出,如果子类继承父类的方法,子类覆盖了父类的静态方法,
    子类的实例继承了父类的static_method静态方法,调用该方法,还是调用的父类的方法和类属性。

    子类的实例继承了父类的class_method类方法,调用该方法,调用的是子类的方法和子类的类属性。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 14
    
        @staticmethod
        def averag(*mixes):  # "父类中的静态方法"
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # "父类中的静态方法"
            print "父类中的静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 父类中的类方法
            print "父类中的类方法"
            return cls.averag(cls.X, cls.Y)
    
    
    class Son(Foo):
        X = 3
        Y = 5
    
        @staticmethod
        def averag(*mixes):  # "子类中重载了父类的静态方法"
            print "子类中重载了父类的静态方法"
            print "666 ",mixes
            return sum(mixes) / 3
    
    p = Son()
    print "result of p.averag(1,5)"
    print (p.averag(1,5))
    print "result of p.static_method()"
    print(p.static_method())
    print "result of p.class_method()"
    print(p.class_method())

    结果如下:

    result of p.averag(1,5)
    子类中重载了父类的静态方法
    666  (1, 5)
    2
    result of p.static_method()
    父类中的静态方法
    7
    result of p.class_method()
    父类中的类方法
    子类中重载了父类的静态方法
    666  (3, 5)
    2

    Process finished with exit code 0

    参考网址:https://zhuanlan.zhihu.com/p/21101992

    展开全文
  • Python进阶之路 静态方法和类方法

    万次阅读 多人点赞 2019-06-18 18:57:00
    静态方法和类方法 Python类包含三种方法:实例方法、静态方法和类方法。其中,实例方法在前面的章节已经多次使用了。要想调用实例方法,必须要实例化类,然后才可以调用。也就是说,调用实例化方法需要类的实例(对象...

    静态方法和类方法

    Python类包含三种方法:实例方法、静态方法和类方法。其中,实例方法在前面的章节已经多次使用了。要想调用实例方法,必须要实例化类,然后才可以调用。也就是说,调用实例化方法需要类的实例(对象)。而静态方法在调用时根本不需要类的实例(静态方法不需要self参数),这一点和其他编程语言完全一样。

    类方法的调用方式与静态方法完全一样,所不同的是,类方法与实例方法的定义方式相同,都需要一个self参数,只不过这个self参数的含义不同。对于实例方法来说,这个self参数就代表当前类的实例,可以通过self访问对象中的方法和属性。而类方法的self参数表示类的元数据,也就是类本身,不能通过self参数访问对象中的方法和属性,只能通过这个self参数访问类的静态方法和静态属性。

    定义静态方法需要使用@staticmethod装饰器(decorator),定义类方法需要使用@classmethod装饰器。

    class Myclass:
        # 实例方法
        def instancemethod(self):
            pass
        # 静态方法
        @staticmethod
        def staticmethod():
            pass
        # 类方法
        @classmethod
        def classmethod(self):
            pass
    

    [例 10.9] 本例演示了如何定义实例方法、静态方法和类方法,并演示了如何调用这些方法

    class Myclass:
        # 定义一个静态变量,可以被静态方法和类方法访问
        name = 'Bill'
        def __init__(self):
            print('Myclass的构造方法被调用')
            # 定义实例变量,静态方法和类方法不能访问该变量
            self.value = 20
        # 定义静态方法
        @staticmethod
        def run():
            # 访问Myclass类中的静态变量name
            print('*', Myclass.name, '*')
            print('Myclass的静态方法run被调用')
    
        # 定义类方法
        @classmethod
        # 这里self是类的元数据,不是类的实例
        def do(self):
            print(self)
            # 访问Myclass类中的静态变量name
            print('[', self.name, ']')
            print('调用静态方法run')
            self.run()
            # 在类方法中不能访问实例变量,否则会抛出异常(因为实例变量需要用类的实例访问) print(self.value)
            print('成员方法do被调用')
        # 定义实例方法
        def do1(self):
            print(self.value)
            print('<', self.name, '>')
            print(self)
    # 调用静态方法run
    Myclass.run()
    # 创建Myclass类的实例
    c = Myclass()
    # 通过类的实例也可以调用类方法
    c.do()
    # 通过类访问类的静态变量
    print('Myclass2.name', '=', Myclass.name)
    # 通过类调用类方法
    Myclass.do()
    # 通过类的实例访问实例方法
    c.do1()
    

    输出结果:

    * Bill *
    Myclass的静态方法run被调用
    Myclass的构造方法被调用
    <class '__main__.Myclass'>
    [ Bill ]
    调用静态方法run
    * Bill *
    Myclass的静态方法run被调用
    成员方法do被调用
    Myclass2.name = Bill
    <class '__main__.Myclass'>
    [ Bill ]
    调用静态方法run
    * Bill *
    Myclass的静态方法run被调用
    成员方法do被调用
    20
    < Bill >
    <__main__.Myclass object at 0x10d5bcd30>
    

    从实例方法、静态方法和类方法的调用规则可以得出以下结论:

    通过实例定义的变量只能被实例方法访问,而直接在类中定义的静态变量(如本例的name变量)即可以被实例方法访问,也可以被静态方法和类方法访问。实例方法不能被静态方法和类方法访问,但静态方法和类方法可以被实例方法访问。

    展开全文
  • 【 静态方法:1、在被实例化之前就已经存在于内存中,2、静态方法是类所有对象共有的方法,3、可被类或对象调用;非静态方法:1、在类被实例化之后,才加载到内存中,具体存储在堆...类方法(静态方法)是直接可以...

    静态方法:
    1、在被实例化之前就已经存在于内存中,
    2、静态方法是类所有对象共有的方法,
    3、可被类或对象调用;
    非静态方法:
    1、在类被实例化之后,才加载到内存中,具体存储在堆中;
    2、非静态方法被对象所私有;
    3、只能用对象调用(那静态方法中的非静态类呢,猜测,也一起被加载到内存)

    类是封装好的,像一个模型
    对象是由类实例化的,像一个具体的样本
    类中的只有静态方法可以使用

    类方法(静态方法)是直接可以使用类引用,不需要实例化就可以使用的方法,一般在项目中类方法都是设置为工具类使用的

    类实例化了就是对象,

    类的方法不能用,除了static方法,

    对象的方法不是static的也可用,

    用类名引用的就是类方法,

    用对象名引用的就是对象方法。


    比如

    class a
    a ddfdf=new a();
    a.f();  //这个是类的方法,这个方法必得是静态的才行。通常用来取得类的选代器或取的类本身的一个对象
    ddfdf.f();  //这个是对象方法。

     

    静态方法必须定义成static的,在类被实例化以前就已经存在于内存中
    静态方法是所有该类的实例也就是对象共有的方法
    非静态方法,
    只有在类Test被实例化以后,才被加载到内存中,具体存储在堆中,
    非静态方法是每个该类的实例也就是对象所私有的
    静态方法必须既可以用类名直接调用,也可以用对象来调用
    非静态方法只能用对象来调用

     

    类是封装好的,像一个模型;对象是由类实例化的,也就像一个具体的样本!通俗来说吧,比如说“人”就是一个类,而你就是一个实例即对象

     

    类和对象的区别
    1,类是一个抽象的概念,它不存在于现实中的时间/空间里,类只是为所有的对象定义了抽象的属性与行为。就好像“Person(人)”这个类,它虽然可以包含很多个体,但它本身不存在于现实世界上。
    2,对象是类的一个具体。它是一个实实在在存在的东西。
    3,类是一个静态的概念,类本身不携带任何数据。当没有为类创建任何对象时,类本身不存在于内存空间中。
    4,对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

     

    一、类和对象的区别
    1、定义不同

    类是现实世界或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。

    对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

    2、范畴不同

    类是一个抽象的概念,它不存在于现实中的时间、空间里,类知识为所有的对象定义了抽象的属性与行为。

    对象是类的一个具体。它是一个实实在在存在的东西。

    3、状态不同

    类是一个静态的概念,类本身不携带任何数据。当没有为类创建任何数据时,类本身不存在于内存空间

    对象是一个动态的概念,每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为,属性可以随着它自己的行为而发生改变。

    二、类和对象的关系

    类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

    类与对象的关系就如模具和铸件的关系 类的实例化结果就是对象,而对一类对象的抽象就是类,类描述了一组有相同属性和相同方法的对象。

    扩展资料

    使用类时的注意事项:

    1、类的成员可以是其他类的对象,但不能以类自身的对象作为本类的成员,而类自身的指针和引用可以作为类的成员。

    2、类定义必须以分号“;”结束。

    3、类与结构体的区别:没有明确指定类成员的访问权限时,C++结构体的成员是公有的,而类的成员是私有的。

     

    类是一个抽象的概念;
    而对象是类抽象概念的实物表达;
    打个比方:
    比如水果摊进了一批水果(就好比是类);
    然后就去问卖家有哪些新鲜的水果;
    店家说有苹果、梨、桃等等(这里的苹果、梨、桃就是对象);
    也就是说对象是类的具体表达;
    而类则是对象的抽象表达。

     

    类方法必须既可以用类名直接调用,也可以用对象来调用;对象方法只能用对象来调用。

     

    实例方法是建立实例才有的方法
    类方法是直接可以使用类引用,不需要实例化就可以使用的方法,一般在项目中类方法都是设置为工具类使用的

    实例方法是必须创建了一个类的实例之后才能调用的方法 属于一个特定的实例 调用方法为 实例名.方法名();
    而类方法是属于一个类的 是类的静态方法。可以一用类字节调用 ;调用方法是 类名.方法名();
    类方法主要用于工具类的方法。

    转载于:https://www.cnblogs.com/arrows/p/10407476.html

    展开全文
  • Python中类方法定义及常用的实现方式

    万次阅读 多人点赞 2018-10-29 19:02:18
    1. python的属性和方法查看 class Person_1: mind = '有思想' belif = '有信仰' animal = '高级动物' def tt(): pass print(Person_1.__dict__) #查询Person中所有的内容,表现形式是字典. print(Person_...
  • JAVA之间方法的调用

    万次阅读 多人点赞 2018-11-02 23:39:15
    JAVA类方法的调用一、静态方法调用其他方法:1. 静态方法调用非静态方法2.静态方法调用静态方法二、非静态方法调用其他方法1.非静态方法在同一类内调用其他方法2.非静态方法在不同类之间调用其他方法 注:调用方法...
  • 类方法中可用this来调用本类的类方法 B.在类方法中调用本类的类方法时可直接调用 C. 在类方法中只能调用本类中的类方法 D. 在类方法中绝对不能调用实例方法 java中的一些bug题目,有的出题的也没有试过总结了...
  • 类方法和实例方法区别

    万次阅读 2019-06-15 09:13:50
    Objective-C里面既有实例方法也类方法类方法(Class Method) 有时被称为工厂方法(Factory Method)或者方便方法(Convenience method)。工厂方法的称谓明显和一般意义上的工厂方法不同,从本质上来说,类方法可以独立...
  • 类方法和静态方法的区别

    千次阅读 2018-11-11 22:22:59
    类方法、静态方法 类方法 第一个形参是类对象的方法 需要用装饰器@classmethod来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数。 class Dog(object): __type = "狗" ...
  • python中的类属性、实例属性、类方法、实例方法

    万次阅读 多人点赞 2018-07-03 10:45:22
    定义 class Person(): pass 创建实例 xiaoming = Person() xiaohong = Person() 实例属性 xiaoming = Person() xiaoming.name = xiaoming xiaoming.age = 24 xiaoming.sex = man xiaohong = Person() ...
  • Java 类方法

    千次阅读 多人点赞 2018-12-16 12:58:40
    类方法: 又叫做静态方法  对象方法: 又叫实例方法,非静态方法  访问一个对象方法,必须建立在有一个对象的前提的基础上  访问类方法,不需要对象的存在,直接就访问 步骤 1 : 类方法 类方法: 又叫做静态...
  • 在学习python代码时,看到有的类的方法中第一...而cls则一般在类方法中使用,在静态方法中则不需要使用一个默认参数,其实这个默认参数可以换成任何一个名字代替,不会产生任何影响。在下面的代码中,InstanceMeth...
  • Java 类变量和类方法

    万次阅读 2018-05-22 14:16:35
    一、变量1、静态代码块 static{ } 静态代码块只会被执行一次;2、定义的时候,中变量创建在代码区,此时静态代码块会被自动执行;例子:package smm; public class LearnStatic { static int i=1; ...
  • python中的类方法(@classmethod)

    万次阅读 多人点赞 2019-09-11 19:01:49
    类方法也算一种实用的技巧,简单描述之:“类方法让类模板具有记忆力”。 类模板就是我们所定义的类。在普通情况下,不使用类方法对类进行实例化,类本身是不具有记忆性的。只是当一个静态模板被套用多次而已。如果...
  • MAC上 IDEA 显示类方法快捷键

    千次阅读 2019-08-20 00:47:46
    在MAC显示类方法有两种快捷方式 第一种:command +7; 第二种 command + F12;
  • 20.python-类属性和类方法

    千次阅读 2019-11-28 00:49:06
    类属性和类方法 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 —— 实例 使用面相对象开发,第 1 步是设计类 使用类名()创建对象,创建对象的动作有两步: 1) 在内存中为对象...
  • 面向对象(三)、静态方法、类方法

    万次阅读 2020-05-31 20:39:36
    的 私有属性 和 私有方法 ,不能通过对象访问,只能在的内部 通过self访问 的 私有属性 和 私有方法 ,不会被子继承, class MasterWorker(object): def __init__(self): self.mifang="古典秘方" self...
  • java 类方法和实例方法

    万次阅读 多人点赞 2018-03-13 22:55:50
    类方法 用static修饰的方法。 由于类方法是属于整个类的,所以类方法的方法体中不能有与类的对象有关的内容。 即类方法体有如下限制: 1.类方法中不能引用对象变量; 2.类方法中不能调用类的对象方法; 3.在...
  • C++ 类方法和实例方法辨析

    千次阅读 2017-05-08 10:05:05
    首先明确定义: 类方法:即静态方法(静态成员函数),指的是类中被...但是类方法不能调用实例方法,只能调用其他类方法(非绝对,也可以使用传引用的方法让类方法调用实例方法) 性质2:当类文件加载到内存,实例方
  • 类方法能否访问自己的属性

    千次阅读 2016-01-21 13:04:13
    类方法不能直接访问自己的属性 即self.iconImageArr;不能用self访问。 在类方法中要访问自己的属性,必须要在类中实例化一个对象,然后再调用; 如下方代码: // // FirstTableView1.m // xxtnm_iOS_con // // ...
  • Python中的类属性、实例属性与类方法、静态方法

    万次阅读 多人点赞 2017-05-23 14:55:27
    1、什么是对象,实例对象 对象:类名 实例对象:创建的对象 2、属性就是对象所拥有的属性,它被所有对象的实例对象所共有,在内存中只存在一个副本,这个和C++、Java中的静态成员变量有点类似。对于...
  • 是抽象的,在使用的时候通常会找到这个的一个具体的存在,使用这个具体的存在。一个可以找到多个对象对象: 某一个具体事物的存在,在现实世界中可以是看的到摸得着的。...方法:允许对进行操作的...
  • Python普通方法、静态方法、类方法

    万次阅读 2016-08-11 10:31:57
    Python普通方法、静态方法、类方法今天尝试了一下Python普通方法、静态方法、类方法的区别# -*-coding:utf-8-*- # 普通方法,类方法,静态方法的区别__metaclass__ = type class Tst: name = 'tst' data = 'this is ...
  • iOS的类方法和实例方法区别与使用

    千次阅读 2017-02-16 22:37:06
    1.什么是类方法? 在OC类定义方法时以 + 开头的方法,又称为静态方法。如:+ (viod)方法名{ }. 作用:不用实例话就可以直接调用的方法,常用于一些common或者UtiKit等公共方法类中。 调用:[类名 方法名】 限制:...
  • 关于类方法里不能调用实例方法/成员变量的论述 参考《疯狂Java讲义》 首先要明白无论调用成员变量还是方法,都需要主调(主语调用者),其格式为:主调.方法/成员变量 别看我们平时可以直接使用方法名/变量名,...
  • Objective-C里面既有实例方法也类方法类方法(Class Method) 有时被称为工厂方法(Factory Method)或者方便方法(Convenience method)。工厂方法的称谓明显和一般意义上的工厂方法不同,从本质上来说,类方法可以独立...
  • this调用本类方法(基本 /构造)

    万次阅读 多人点赞 2018-02-28 22:46:09
    声明:下面的所有代码都省略了setter getter构造 在本类中访问封装的...方法名称(参数...)构造方法:this(参数...)范例:调用本类方法class Person{ private String name; private int age; public Person() { ...
  • 之前也了解一些,没有完全的理解透彻(就是一知半解),前几天面试被问到这个问题,回答的不是很满意。 先剽窃个图看一下 ... self.x = x #实例方法 # 最常见的实例方法 def foo(self, y=0):
  • 实例方法、类方法、静态方法

    千次阅读 2020-05-23 15:16:01
    实例方法、静态方法和类方法 示例方法:第一个参数为self,必须实例化之后才能调用的方法 类方法:使用@classmethod进行装饰,第一个参数为cls,可以被类调用,也可以被实例调用。 静态方法:使用@staticmethod进行...
  • 类方法,也称静态方法,指的是用static关键字修饰的方法。此方法属类本身的方法,不属于类的某一个实例(对象)。类方法中不可直接使用实例变量。其调用方式有三种:可直接调用、类名.方法名、对象名.方法名。实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,364,281
精华内容 2,945,712
关键字:

类方法