精华内容
下载资源
问答
  • 类方法
    千次阅读
    2020-05-23 15:16:01

    实例方法、静态方法和类方法

    示例方法:第一个参数为self,必须实例化之后才能调用的方法
    类方法:使用@classmethod进行装饰,第一个参数为cls,可以被类调用,也可以被实例调用。
    静态方法:使用@staticmethod进行装饰,没有固定的参数,可以被类调用,也可以被实例调用,一般可以说跟类和实例没有关系。

    
    class A(object):
        #实例方法
        def foo(self,x):
            print("excuting 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("excuting static_foo(%s)"%(x))
    a=A()
    a.foo(11111)   #excuting foo(<__main__.A object at 0x000001F61BC32390>,11111)
    a.class_foo(22222)  #executing class_foo(<class '__main__.A'>,22222)
    a.static_foo(33333)  #excuting static_foo(33333)
    
    更多相关内容
  • 实例方法、类方法、构造方法

    千次阅读 多人点赞 2019-11-19 14:11:00
    Java中类的方法分为类方法(用static修饰,也叫静态方法)和实例方法(没有用static修饰,也叫非静态方法) 实例方法,就是一般的方法 类方法,有static修饰符,典型的主函数 构造方法,没有返回值(就是连void都没有...

    Java中类的方法分为类方法(用static修饰,也叫静态方法)和实例方法(没有用static修饰,也叫非静态方法)
    实例方法,就是一般的方法
    类方法,有static修饰符,典型的主函数
    构造方法,没有返回值(就是连void都没有),方法名与类名一样

    public static void myMethod();//类方法
    public void myMethod2();//实例方法
    public Test(){}//构造方法,没有返回值,方法名与类名一样
    

    实例方法与类方法的区别:

    1、类方法是属于整个类,而不属于某个对象。
    2、类方法只能访问类成员变量,不能访问实例变量,而实例方法可以访问类成员变量和实例变量。
    3、在类方法中不能使用super、this关键字。
    4、类方法的调用可以通过类名.类方法和对象.类方法,而实例方法只能通过对象.实例方法访问。
    5、类方法只能访问类方法,而实例方法可以访问类方法和实例方法。
    6、类方法不能被覆盖,实例方法可以被覆盖。
    
    1. 构造方法—构造方法负责对象的初始化工作,为实例变量赋予合适的初始值。必须满足以下的语法规则:
    1、方法名与类名相同;
    2、不要返回类型(例如return、void等);
    3、不能被static、final、native、abstract和synchronized修饰,不能被子类继承
    

    1.1. 默认构造方法—默认构造方法时没有参数的构造方法,分为

    a.隐含的默认构造方法:public ClassName(){}
    b.程序显示定义默认构造方法:public Employee(){this("无名氏");}
    

    1.2. 重载构造方法—通过new创建一个对象后,在不同的条件下,对象可能会有不同的初始化行为,可以通过重载构造方法来表达对象的初始化行为。具体参考this关键字的用法。
    1.3. 子类调用父类的构造方法—父类的构造方法不能被子类调用,可以通过super语句调用父类的构造方法。例如:
    在这里插入图片描述
    用super调用父类的构造方法必须遵守以下规则:

    1. 子类的构造方法中不能直接通过父类的方法名调用父类的构造方法,使用super语句;
    2. 加入在子类的构造方法中有super语句,它必须作为构造方法的第一条语句(同this语句);
    

    1.4. 构造方法的作用域

    1、当前类的其他构造方法通过this语句调用;
    2、当前类的子类的构造方法通过super语句调用;
    3、在程序中通过new语句调用。
    

    1.5. 构造方法的private访问级别— 构造方法为private级别时,意味着只能在当前类中访问它:当前类的其他构造方法中可以通过this语句调用,此外还可以在当前类的成员方法中使用new调用。
    以下场合中,可以把类的所有构造方法声明为private:

    1、这个类中仅仅包含一些供其他程序调用的静态方法,没有任何实例方法。
    2、禁止这个类被继承。声明为private后,如果定义了它的子类,子类的方法中无法调用父类的任何构造方法。
    3、类需要把构造自身实例的细节封装起来,不允许其他程序通过new语句创建这个类的实例。提供静态方法。
    
    展开全文
  • 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

    展开全文
  • Java 基础之实例方法,实例变量,类方法,类变量

    千次阅读 多人点赞 2019-05-18 09:08:17
    实例变量(instance variable) 实例变量:或叫实例域、实例字段...实例方法:或叫成员方法(member method)。供实例用的方法,必须要先有实例,才能通过此实例调用实例方法变量(class variable) ...
  • 类方法中可用this来调用本类的类方法 B.在类方法中调用本类的类方法时可直接调用 C. 在类方法中只能调用本类中的类方法 D. 在类方法中绝对不能调用实例方法 java中的一些bug题目,有的出题的也没有试过总结了...
  • 一、类方法和实例方法的调用先看一道选择题:下列哪种说法是正确的( )A. 实例方法可直接调用超类的实例方法B. 实例方法可直接调用超类的类方法C. 实例方法可直接调用其他类的实例方法D. 实例方法可直接调用本类...
  • 20.python-类属性和类方法

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

    千次阅读 多人点赞 2018-11-11 22:22:59
    类方法、静态方法 类方法 第一个形参是类对象的方法 需要用装饰器@classmethod来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数。 class Dog(object): __type = "狗" ...
  • 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_...
  • 类方法和实例方法区别

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

    千次阅读 2019-10-29 09:23:09
    在C++内部方法调用时,一般都是先去定义一个的变量,实例化之后再通过对象去调用内部的函数。在项目中发现另一种比较方便的方法,不需要定义对象,话不多说直接上代码。 实例代码如下: #include <...
  • java 类方法和实例方法 调用关系

    万次阅读 多人点赞 2018-04-20 23:49:55
    java 类方法和实例方法 1. 类方法 也可称静态方法,使用static修饰的类中方法; 2.实例方法 非静态方法,没有用static修饰的方法。 3.测试案例 public class Test { private int a = 5; private ...
  • 一、类方法 类方法是静态方法,前面需要有static修饰符修饰。类方法内不能涉及有关变量的内容 1、不能调用类的对象方法 2、不能引用对象变量 3、类方法不能被重写(覆盖) 4、类方法不能使用super, this关键字 二、...
  • python中的类方法(@classmethod)

    万次阅读 多人点赞 2019-09-11 19:01:49
    类方法也算一种实用的技巧,简单描述之:“类方法让类模板具有记忆力”。 类模板就是我们所定义的类。在普通情况下,不使用类方法对类进行实例化,类本身是不具有记忆性的。只是当一个静态模板被套用多次而已。如果...
  • 在学习python代码时,看到有的类的方法中第一...而cls则一般在类方法中使用,在静态方法中则不需要使用一个默认参数,其实这个默认参数可以换成任何一个名字代替,不会产生任何影响。在下面的代码中,InstanceMeth...
  • MAC上 IDEA 显示类方法快捷键

    万次阅读 2019-08-20 00:47:46
    在MAC显示类方法有两种快捷方式 第一种:command +7; 第二种 command + F12;
  • java 类方法和实例方法

    万次阅读 多人点赞 2018-03-13 22:55:50
    类方法 用static修饰的方法。 由于类方法是属于整个类的,所以类方法的方法体中不能有与类的对象有关的内容。 即类方法体有如下限制: 1.类方法中不能引用对象变量; 2.类方法中不能调用类的对象方法; 3.在...
  • 一、前言 APP 启动到执行 main 函数之前,程序就执行了很多代码。...+load 方法是当或分类被添加到 Objective-C runtime 时被调用的,实现这个方法可以让我们在加载的时候执行一些相关的行为
  • C++ 类方法和实例方法辨析

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

    万次阅读 2017-02-16 11:07:49
    所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。 静态内存是连续的,因为是在程序开始时就生成了,而实例申请的是离散的空间,所以当然没有静态方法快, 而且...
  • java导入其他类方法--import使用方法

    万次阅读 多人点赞 2019-03-21 20:56:39
    java导入其他类方法–import使用方法 A:类在同一个包 类名 对象名 =new 类名(); 例子: 被调用类Demo.java package com.test1;//属于同一个包 public class Demo{ public static void main(String[] args){ ...
  • Python中的类属性、实例属性与类方法、静态方法

    万次阅读 多人点赞 2017-05-23 14:55:27
    1、什么是对象,实例对象 对象:类名 实例对象:创建的对象 2、属性就是对象所拥有的属性,它被所有对象的实例对象所共有,在内存中只存在一个副本,这个和C++、Java中的静态成员变量有点类似。对于...
  • java里类方法和实例方法区别

    千次阅读 2017-12-24 12:55:02
    我们已经知道类体中的方法分为实例方法和类方法两种,用static修饰的是类方法。二者有什么区别呢?当一个类创建了一个对象后,这个对象就可以调用该类的方法。 当类的字节码文件被加载到内存时,类的实例方法...
  • Python进阶之路 静态方法和类方法

    万次阅读 多人点赞 2019-06-18 18:57:00
    静态方法和类方法 Python类包含三种方法:实例方法、静态方法和类方法。其中,实例方法在前面的章节已经多次使用了。要想调用实例方法,必须要实例化类,然后才可以调用。也就是说,调用实例化方法需要类的实例(对象...
  • 关于类方法里不能调用实例方法/成员变量的论述 参考《疯狂Java讲义》 首先要明白无论调用成员变量还是方法,都需要主调(主语调用者),其格式为:主调.方法/成员变量 别看我们平时可以直接使用方法名/变量名,...
  • 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):
  • 【 静态方法:1、在被实例化之前就已经存在于内存中,2、静态方法是类所有对象共有的方法,3、可被类或对象调用;非静态方法:1、在类被实例化之后,才加载到内存中,具体存储在堆...类方法(静态方法)是直接可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,471,146
精华内容 3,388,458
关键字:

类方法