相关疑难解决方法(0)

静态类和单例模式之间存在什么真实(即实际)差异？

两者都可以在没有实例化的情况下调用,两者都只提供一个"实例",它们都不是线程安全的.还有其他区别吗？

问题是在Java中为什么我不能定义一个抽象的静态方法？例如

abstract class foo {
    abstract void bar( ); // <-- this is ok
    abstract static void bar2(); //<-- this isn't why?
}

调用静态方法的标准方法是什么？我可以考虑使用constructor或使用类本身的名称,我不喜欢后者,因为它没有必要.前者是推荐的方式,还是还有其他的东西？

这是一个(人为的)例子:

class SomeObject {
  constructor(n){
    this.n = n;
  }

  static print(n){
    console.log(n);
  }

  printN(){
    this.constructor.print(this.n);
  }
}

我想知道:

1. 为什么不能在Java中覆盖静态方法？
2. Java中是否可以重载静态方法？

我用Java编写了这个程序

public class Why {

  public static void test() {
    System.out.println("Passed");
  }

  public static void main(String[] args) {
    Why NULL = null;
    NULL.test();
  }

}

我读到调用一个null对象的方法导致NullPointerException,但上面的程序没有？为什么是这样？我不正确地理解某事吗？

在这里参考关于python的绑定和未绑定方法的第一个答案,我有一个问题:

class Test:
    def method_one(self):
        print "Called method_one"
    @staticmethod
    def method_two():
        print "Called method_two"
    @staticmethod
    def method_three():
        Test.method_two()
class T2(Test):
    @staticmethod
    def method_two():
        print "T2"
a_test = Test()
a_test.method_one()
a_test.method_two()
a_test.method_three()
b_test = T2()
b_test.method_three()

产生输出:

Called method_one
Called method_two
Called method_two
Called method_two

有没有办法在python中覆盖静态方法？

我希望b_test.method_three()打印"T2",但它没有(打印"Called method_two"代替).

Smalltalk和Java中的OO有哪些主要区别？

请注意,我是一名Java程序员,试图通过探索Smalltalk来扩展他的视野.目前我对Smalltalk几乎一无所知,只不过它比Java更纯净.因此,我更喜欢这个答案,它展示了各种Java概念如何映射到相应的Smalltalk概念,然后介绍了Java中根本不存在的Smalltalk概念.

在Scala编程:综合循序渐进指南中,作者说:

Scala比Java更面向对象的一种方式是Scala中的类不能有静态成员.相反,Scala具有单例对象.

为什么单例对象更面向对象？不使用静态成员有什么好处,而是使用单例对象？

我知道我们不能在Java中覆盖静态方法,但有人可以解释下面的代码吗？

class A {
    public static void a() { 
        System.out.println("A.a()");
    }
}   

class B extends A {
    public static void a() {
        System.out.println("B.a()");
    }
}

我怎么能a()在课堂上覆盖方法B？

根据这个答案和答案,Java静态方法不是虚拟的,不能被覆盖.因此,直观地说,这应该有效(即使在99%的情况下,这是危险的编程):

class Foo
{
    public static String frob() {
        return "Foo";
    }
}

class Bar extends Foo
{
    public static Number frob() {
        return 123;
    }
}

但是,在实践中,这会让你:

Foo.java:10: frob() in Bar cannot override frob() in Foo; attempting to use incompatible return type
found   : java.lang.Number
required: java.lang.String
    public static Number frob() {
                         ^

天真地,似乎Foo.frob()并且Bar.frob()应该与彼此无关; 然而Java坚持认为他们这样做.为什么？

(Nb:我不想听到为什么以这种方式编码是个坏主意,我想听听Java和/或JVM设计中的内容,这使得这个限制成为必要.)

更新以添加:对于那些认为编译器会因为在实例上调用静态方法而感到困惑的人,如果你允许这样做:它不会.它已经在方法签名的情况下算出这个是兼容的:

class Foo
{
    static String frob() {
        return "Foo";
    }
} …