精华内容
参与话题
问答
  • 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 实例方法、类方法和静态方法

    万次阅读 多人点赞 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
    展开全文
  • Java 类方法

    千次阅读 多人点赞 2018-12-16 12:58:40
    类方法: 又叫做静态方法  对象方法: 又叫实例方法,非静态方法  访问一个对象方法,必须建立在有一个对象的前提的基础上  访问类方法,不需要对象的存在,直接就访问 步骤 1 : 类方法 类方法: 又叫做静态...

    类方法: 又叫做静态方法 

    对象方法: 又叫实例方法,非静态方法 

    访问一个对象方法,必须建立在有一个对象的前提的基础上 
    访问类方法,不需要对象的存在,直接就访问

    步骤 1 : 类方法

    类方法: 又叫做静态方法
    对象方法: 又叫实例方法,非静态方法
    访问一个对象方法,必须建立在有一个对象的前提的基础上
    访问类方法,不需要对象的存在,直接就访问

    package charactor;
     
    public class Hero {
        public String name;
        protected float hp;
     
        //实例方法,对象方法,非静态方法
        //必须有对象才能够调用
        public void die(){
            hp = 0;
        }
         
        //类方法,静态方法
        //通过类就可以直接调用
        public static void battleWin(){
            System.out.println("battle win");
        }
         
        public static void main(String[] args) {
               Hero garen =  new Hero();
               garen.name = "盖伦";
               //必须有一个对象才能调用
               garen.die();
                
               Hero teemo =  new Hero();
               teemo.name = "提莫";
                
               //无需对象,直接通过类调用
               Hero.battleWin();
             
        }
    }

    步骤 2 : 调用类方法

    和访问类属性一样,调用类方法也有两种方式
    1. 对象.类方法

    garen.battleWin();

    2. 类.类方法

    Hero.battleWin();

    这两种方式都可以调用类方法,但是建议使用第二种 类.类方法 的方式进行,这样更符合语义上的理解。
    并且在很多时候,并没有实例,比如在前面练习的时候用到的随机数的获取办法

    Math.random()

    random()就是一个类方法,直接通过类Math进行调用,并没有一个Math的实例存在。

    步骤 3 : 什么时候设计对象方法,什么时候设计类方法

    如果在某一个方法里,调用了对象属性,比如

    public String getName(){
        return name;
    }

    name属性是对象属性,只有存在一个具体对象的时候,name才有意义。 如果方法里访问了对象属性,那么这个方法,就必须设计为对象方法

    如果一个方法,没有调用任何对象属性,那么就可以考虑设计为类方法,比如

    public static void printGameDuration(){
        System.out.println("已经玩了10分50秒");
    }

    printGameDuration 打印当前玩了多长时间了,不和某一个具体的英雄关联起来,所有的英雄都是一样的。 这样的方法,更带有功能性色彩

    步骤 4 : 练习-类方法

    在一个类方法中,直接调用一个对象方法,
    比如在battleWin中调用die()
    能否直接调用? 为什么?

    展开全文
  • 类方法和实例方法区别

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

    Objective-C里面既有实例方法也类方法。类方法(Class Method) 有时被称为工厂方法(Factory Method)或者方便方法(Convenience method)。工厂方法的称谓明显和一般意义上的工厂方法不同,从本质上来说,类方法可以独立于对象而执行,所以在其他的语言里面类方法有的时候被称为静态方法。
    注意点一:类方法
    1,类方法可以调用类方法。
    2,类方法不可以调用实例方法,但是类方法可以通过创建对象来访问实例方法。
    3,类方法不可以使用实例变量。类方法可以使用self,因为self不是实例变量。
    4,类方法作为消息,可以被发送到类或者对象里面去(实际上,就是可以通过类或者对象调用类方法的意思
    注意点二:类方法和实例方法
    1:实例方法是— 类开头是+ 实例方法是用实例对象访问,类方法的对象是类而不是实例,通常创建对象或者工具类。
    在实例方法里,根据继承原理发送消息给self和super其实都是发送给self
    在类方法里面self是其他的类的类方法,在类方法中给self发送消息只能发类方法self是类super也是
    什么时候用类方法,要创建一个实例时候获取一个共享实例,或者获取关于类的一些共有信息
    2:类方法(class method)和实例方法(instance method)。类方法被限定在类范围内,不能被类的实例调用(即脱离实例运行)。alloc就是一种类方法。实例方法 限定在对象实例的范围内(即实例化之前不能运行)。init就是一种实例方法,被alloc方法返回的对象实例调用。
    instance method 以减号 “-” 开头
    class method 以加号 “+” 开头,相当于static方法

     1 #import <Foundation/Foundation.h>
     2 /*
     3  对象方法
     4  1> 减号 - 开头
     5  2> 只能由对象来调用
     6  3> 对象方法中能访问当前对象的成员变量(实例变量)
     7  
     8  类方法
     9  1> 加号 + 开头
    10  2> 只能由类(名)来调用
    11  3> 类方法中不能访问成员变量(实例变量)
    12  
    13  
    14  类方法的好处和使用场合
    15  1> 不依赖于对象,执行效率高
    16  2> 能用类方法,尽量用类方法
    17  3> 场合:当方法内部不需要使用到成员变量时,就可以改为类方法
    18  
    19  可以允许类方法和对象方法同名
    20  */
    21 
    22 
    23 @interface Person : NSObject
    24 {
    25     int age;
    26 }
    27 
    28 // 类方法都是以+开头
    29 + (void)printClassName;
    30 
    31 - (void)test;
    32 + (void)test;
    33 
    34 @end
    35 
    36 @implementation Person
    37 
    38 + (void)printClassName
    39 {
    40     // error:instance variable 'age' accessed in class method
    41     // 实例变量age不能在类方法中访问
    42     //NSLog(@"这个类叫做Person-%d", age);
    43 }
    44 
    45 - (void)test
    46 {
    47     NSLog(@"111-%d", age);
    48     
    49     //[Person test];
    50 }
    51 
    52 + (void)test
    53 {
    54     // 会引发死循环
    55     //[Person test];
    56     
    57     NSLog(@"333");
    58     
    59     // 会引发死循环
    60 //    /[Person test];
    61 }
    62 
    63 @end
    64 
    65 int main()
    66 {
    67     //[Person printClassName];
    68     
    69     [Person test];
    70     
    71     //Person *p = [Person new];
    72     //[p test];
    73     
    74     /*
    75      -[Person printClassName]: unrecognized selector sent to instance 0x7fa520c0b370
    76      */
    77     // 系统会认为现在调用的printClassName是个对象方法
    78     //[p printClassName];
    79     
    80     return 0;
    81 }
    

    转载博客园 iOS_bowen.

    展开全文
  • java 类方法和实例方法

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

    千次阅读 多人点赞 2018-12-19 14:49:18
    除了静态方法与类方法外,类的其他方法都属于实例方法。 实例方法隐含的参数为类实例self。 实例方法需要将类实例化后才可以调用,如果使用类直接调用实例方法,需要显示地将实例对象作为参数传入。 **直接...
  • java 类方法和实例方法 调用关系

    万次阅读 多人点赞 2018-04-20 23:49:55
    java 类方法和实例方法 1. 类方法 也可称静态方法,使用static修饰的类中方法; 2.实例方法 非静态方法,没有用static修饰的方法。 3.测试案例 public class Test { private int a = 5; private ...
  • SVM多分类方法

    千次阅读 2016-07-19 17:50:56
    SVM多分类方法   (2012-04-12 09:46:51) 转载▼     SVM多分类方法的实现根据其指导思想大致有两种: (1)将多问题分解为一系列SVM可直接求解的两问题,基于这一系列SVM求解结果得出最终...
  • 类方法和静态方法的区别

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

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

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

    千次阅读 2019-11-28 00:49:06
    类属性和类方法 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 —— 实例 使用面相对象开发,第 1 步是设计类 使用类名()创建对象,创建对象的动作有两步: 1) 在内存中为对象...
  • 类方法成员变量:包括实例变量和类变量,用static修饰的是类变量,不用static修饰的是实例变量,所有类的成员变量可以通过this来引用。类变量:静态域,静态字段,或叫静态变量,它属于该类所有实例共有的属性。而且...
  • 在一个类中,可能出现三种方法,实例方法、静态方法和类方法,下面来看看三种方法的不同: 1、实例方法 实例方法的第一个参数必须是”self”,实例方法只能通过类实例进行调用,这时候“self”就代表这个类实例...
  • Swift 类方法和实例方法

    千次阅读 2015-08-27 14:35:50
    Swift 类方法和实例方法
  • C++ 类方法和实例方法辨析

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

    万次阅读 2014-08-17 15:22:42
    静态方法和实例方法的区别主要体现在两个方面: 1. 在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。...3. 类方法可以被对象调用,也可以被实例调
  • 类方法和对象方法的区别

    千次阅读 2016-06-13 20:50:46
    类方法和对象方法的区别 0. 对象方法以-开头 类方法以+开头 1. 对象方法必须用对象调用 类方法必须用类来调用 2. 对象方法中可以直接访问属性(成员变量) 类方法中不可以直接访问属性(成员变量) 3. ...
  • python3 实例方法,类方法,静态方法

    千次阅读 2017-06-17 09:59:05
    实例方法 顾名思义 类实例化后才能...类方法 @classmethod def classget(cls): print(cls.x) 只能调用类属性 ,类对象和实例都可以调用静态方法 静态方法 @staticmethod def add(a, b):  print (a + b)
  • 实例方法和类方法区别

    万次阅读 2013-09-03 15:22:44
    1、类方法是属于整个类,而不属于某个对象。2、类方法只能访问类成员变量,不能访问实例变量,而实例方法可以访问类成员变量和实例变量。3、类方法的调用可以通过类名.类方法和对象.类方法,而实例方法只能通过对象....
  • Python静态方法和类方法深度总结

    千次阅读 2017-06-17 22:46:40
    Python静态方法和类方法深度总结
  • java里类方法和实例方法区别

    千次阅读 2017-12-24 12:55:02
    我们已经知道类体中的方法分为实例方法和类方法两种,用static修饰的是类方法。二者有什么区别呢?当一个类创建了一个对象后,这个对象就可以调用该类的方法。 当类的字节码文件被加载到内存时,类的实例方法...
  • python中类方法,实例方法,静态方法的作用和区别 Python中至少有三种比较常见的方法类型,即实例方法,类方法、静态方法。它们是如何定义的呢?如何调用的呢?它们又有何区别和作用呢?且看下文。 首先,这三种...
  • 类方法又叫静态方法, 实例方法又叫非静态方法类方法可以直接通过类名调用,实例方法必需先初始化类的实例,然后通过类的实例才能调用举例:class ABC{ public static void testStatic(){System.out.println("...
  • Java中类方法与实例方法的区别

    万次阅读 多人点赞 2016-05-11 20:03:33
    Java中类的方法分为类方法(用static修饰,也叫静态方法)和实例方法(没有用static修饰,也叫非静态方法),这两种方法之间有什么区别呢? 一. 实例方法 当类的字节码文件加载到内存中时,类的实例方法并没有被...
  • 总是被这些相似的概念搞晕,查阅了资料...java类的成员变量包括实例变量和类变量,成员方法包括实例方法和类方法。 那么,什么是实例变量和类变量呢? 从名字分析: 实例变量,是新建了实例后才能用的变量。 类变量,是
  • python中的类方法(@classmethod)

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

    千次阅读 2017-09-21 15:37:40
    使用Method Swizzling 方法 swizzling大多时候是在category中的+load方法中使用,也...+initialize 方法是在程序调用第一个实例方法/类方法时调用 +load 方法是在初始化时调用 + (void)load {  stat
  • python class 通过类方法修改类属性

    千次阅读 2019-04-08 10:13:38
    通过类方法修改类属性 ‘’’ class Person(object): country = ‘中国’ @classmethod def countryinfo(cls): pass @classmethod def changecountry(cls,newcountry): cls.country = newcountry print(‘此时的国籍...
  • OCMock 测试类方法

    千次阅读 2011-12-27 14:25:44
    OCMock 测试类方法 罗朝辉(http://blog.csdn.net/kesalin) CC许可,转载请注明出处 使用 OCMock 进行 unit test 时,我们无法 stub 或 expect 类方法,那么又该怎样测试类方法呢?下面是一个解决办法:在测试类中...

空空如也

1 2 3 4 5 ... 20
收藏数 992,675
精华内容 397,070
关键字:

类方法