标签: static-methods

我知道他们做了什么,我已经看到了很多这两个例子,但我没有找到一个例子,我必须使用classmethod而不是用一个替换它staticmethod.

classmethod我见过的最常见的例子是创建一个类本身的新实例,就像这样(非常简化的例子,没有使用方法atm.但你明白了):

class Foo:
    @classmethod
    def create_new(cls):
        return cls()

这会Foo在调用时返回一个新实例foo = Foo.create_new().现在为什么我不能只使用它:

class Foo:
    @staticmethod
    def create_new():
        return Foo()

它完全相同,我为什么要使用classmethoda staticmethod？

在swift中,如果没有使用类名称为方法调用添加前缀,则实例func不能调用a static/class func.或者你可以使用type(of: self),例如

class Foo {
    static func doIt() { }

    func callIt() {
        Foo.doIt() // This works
        type(of: self).doIt() // Or this

        doIt() // This doesn't compile (unresolved identifier)
    }
}

我的问题是,这有什么区别？它只是编码风格的问题,还是存在一些差异,例如静态或动态调度？

如果它只是编码风格,那么首选的风格是什么？

这是什么？

public class ABC {
   public ABC() {
         System.out.println("world");
   }
   static {
         System.out.println("hello");
   }
}

将打印:你好世界

我真的不明白这个,或者静态代码是什么样的方法.

由于第三方库的布局,我有类似下面的代码:

struct Base
{
    static void SomeStaticMethod(){}
};

struct Derived1: private Base {};

struct Derived2: public Derived1 {
    void SomeInstanceMethod(){
        Base::SomeStaticMethod();
    }
};

int main() {
    Derived2 d2;
    d2.SomeInstanceMethod();

    return 0;
}

我正在使用MSVC获得编译器错误C2247:

Base :: SomeStaticMethod无法访问,因为Derived1使用private从Base继承.

我知道我不能访问Base从成员Derived2通过继承,因为私人符,但我仍然应该能够调用静态方法Base-无论之间的继承关系Base和Derived2.
如何解决歧义并告诉编译器我只是调用静态方法？

我编写了以下代码并为超类创建了对象.

class SuperClass{
    static int a=2;
    static int b(){
        return 2;
    }
    int c(){
        return 2;
    }

    SuperClass(){
        System.out.println("Super");
    }
    static {
        System.out.println("super");
    }
}

public class Sub extends SuperClass{
    Sub(){
    System.out.println("Sub");
    }
    static {
        System.out.println("sub");
    } 
    static int b(){
        return 3;
    }
    int c(){
        return 3;
    }
    public static void main(String ax[]){
        SuperClass f =new SuperClass();
        System.out.println(f.c());
        System.out.print(SuperClass.b());
    }   
}

当我检查输出时,它如下:

super
sub
Super
2
2

我知道只有在初始化类的对象或进行任何静态引用时才执行静态块.但在这里,我没有将这些中的任何一个发给Sub类.那为什么我看到"sub"即子类'静态块输出？

我有

class foo{

   public static void main(String[] args){
      do();
   }

   public void do(){}


}

但后来当我打电话do()从main通过运行以下命令java foo在命令行上,JAVA抱怨说,你不能调用从静态功能的方法.

所以我的问题是:如何从main方法调用方法,如果不可能,在使用java命令从命令行运行程序之后调用方法的替代策略是什么.

示例代码是:

    public class OverloadingTest {

       public static void test(Object obj){
           System.out.println("Object called");
       }

       public static void test(String obj){
           System.out.println("String called");
       }

       public static void main(String[] args){
           test(null);
           System.out.println("10%2==0 is "+(10%2==0));
           test((10%2==0)?null:new Object());
           test((10%2==0)?null:null);
   }

输出是:

名为
10%2 == 0的 字符串为true
称为
String的对象称为

第一次调用test(null)带String参数调用方法,这是可以理解的The Java Language Specification.

1)任何人都可以解释我test()在前面的电话中调用的基础吗？

2)当我们提出时,说一个if条件:

    if(10%2==0){
        test(null);
    }
    else
    {
        test(new Object());
    }

它总是使用String参数调用方法.

编译(10%2)时编译器会计算表达式吗？我想知道表达式是在编译时还是在运行时计算的.谢谢.

采用以下示例脚本:

class A(object):
    @classmethod
    def one(cls):
        print("I am class")

    @staticmethod
    def two():
        print("I am static")


class B(object):
    one = A.one
    two = A.two


B.one()
B.two()

当我使用Python 2.7.11运行此脚本时,我得到:

I am class
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    B.two()
TypeError: unbound method two() must be called with B instance as first argument (got nothing instead)

似乎@classmethod装饰器在类中保留,但@staticmethod不是.

Python 3.4的行为符合预期:

I am class
I am static

为什么Python2不能保留@staticmethod,是否有解决方法？

编辑:从课堂上取两个(并保留@staticmethod)似乎有效,但这对我来说似乎仍然很奇怪.

为什么在PHP中你可以通过某个类的实例访问静态方法,但不仅仅是通过类型名称？

更新:我是.net开发人员,但我也与PHP开发人员合作.最近我发现了关于从实例调用的静态方法的这一刻,并且无法理解为什么它可以是有用的.

例:

class Foo
{
    public static Bar()
    {
    }
}

我们可以接受这样的方法:

var $foo = new Foo();
$foo.Bar(); // ??????

我不是面向对象编程的专家,我有一个愚蠢的问题:

class test {
    public static function doSomething($arg) {
        $foo = 'I ate your ' . $arg;
        return $foo;
    }
}

所以调用doSomething()方法的正确方法是做test::doSomething('Pizza');,我是对的吗？

现在,如果我这样称呼会发生什么:

$test = new test;
$bar = $test->doSomething('Sandwich');

我已经测试了它并且没有任何错误或通知等工作但是这样做是否正确？