标签: static-methods

public class CallingStaticMethod {
public static void method() {
    System.out.println("I am in method");
}
public static void main(String[] args) {
    CallingStaticMethod csm = null;
    csm.method();
   }
}

有人可以解释如何在上面的代码中调用静态方法吗？

关于为什么没有抽象的静态方法/字段,已经有几个SO问题,但我想知道如何实现以下伪代码:

class Animal {
    abstract static int getNumberOfLegs(); // not possible
}

class Chicken inherits Animal {
    static int getNumberOfLegs() { return 2; }


class Dog inherits Animal {
    static int getNumberOfLegs() { return 4; }

这是问题:假设我想确保每个继承的类Animal都包含getNumberOfLegs()方法(即几乎像一个接口,除了我确实希望抽象类实现所有子类共有的几个方法,因此纯接口不会在这里工作).getNumberOfLegs()显然应该是一个静态的方法(假设在一个完美的世界中,我们不会使鸡和狗瘫痪,因此getNumberOfLegs不依赖于实例).

如果没有"抽象静态"方法/字段,可以将方法从Animal类中删除,然后存在某些子类没有该方法的风险.或者可以制作getNumberOfLegs一个实例方法,但是必须实例化一个类以找出动物有多少腿 - 即使它没有必要.

人们通常如何实施这种情况？

编辑:我在这里如何使用它.假设(现在这很荒谬,但无论如何......)每只动物的腿数是独一无二的,所以我可能有类似的东西:

Animal getModelAnimal(int numberOfLegs) {
   if (numberOfLegs == Chicken.getNumberOfLegs()) return new Chicken();
   else if (numberOfLegs == Dog.getNumberOfLegs()) return new Dog();
}

以下是一个无意义的扩展方法示例:

public static class MyExtensions
{
    public static int MyExtensionMethod(this MyType e)
    {
        int x = 1;
        x = 2;

        return x
    }
}

假设执行线程完成并包括该行:

x = 2; 

处理器然后上下文切换,另一个线程进入相同的方法并完成该行:

int x = 1;

假设第一个线程创建并分配的变量"x"在一个单独的堆栈上由第二个创建并分配的变量"x",我是否正确,这意味着该方法是可重入的？

我感兴趣的是我是否应该手动内联在一些性能敏感算法中称为100k-100万次的小方法.

首先,我认为,由于没有内联,我会产生一些开销,因为JVM必须找到是否要内联这个方法(甚至不能这样做).

然而,前几天,我用静态方法的调用替换了这个手动内联代码,并看到了性能提升.怎么可能？这是否表明实际上没有开销,让JVM内联"意志"实际上提升了性能？或者这在很大程度上取决于平台/架构？

(发生性能提升的例子是用int t = a[i]; a[i] = a[j]; a[j] = t;静态方法调用替换数组交换()swap(int[] a, int i, int j).另一个没有性能差异的例子是当我内联一个10-liner方法时,称为1000000次.)

我广泛使用了一个特定静态类的成员函数.每当我调用它时,指定类名的方法看起来很讨厌......

我可以导入静态类作为命名空间来调用其方法而不指定类名C#吗？

想象一下,有一个Customer带有实例Load()方法的类.

Load()调用该方法时,它会通过例如检索订单详细信息

var orders = Order.GetAll(customerId, ...);

GetAll()是类的静态方法,Order输入参数是Customer类中定义的字段.

正如您所看到的,Order是Customer类的依赖项,但是,我不能只创建一个IOrder并将其注入,因为接口不能有静态方法.

因此,问题是如何在此示例中引入依赖注入？

我不想创建GetAll()一个实例方法,因为它是一个静态方法,需要保持这种方式.

例如,我在我的设计中使用了实用程序类,其中大多数只包含静态方法.

我想知道如果我们在静态方法中声明它们,所有局部变量都会变为静态吗？

例如:

  public static void A(){
        int x [] = {3,2};
        changeX(x);

        for (int i = 0; i< x.length; i++){
             System.out.println(x[i]);   // this will print -1 and 1
        }
  }
  private static void changeX(int[] x){
        x[0] = -1;
        x[1] =  1;
  }

据我所知,Java总是按值传递,但是为什么在我们进行changeX调用后X的状态发生了变化？有人可以解释一下吗？任何人都可以解释Java如何在内存分配方面处理静态变量？如果我们将静态变量作为参数传递给函数会发生什么(我知道人们通常不这样做)

我刚刚与我的朋友讨论了使用类名调用静态方法,并尝试了这个代码并期望它在运行时抛出NPE.但事实证明它是dint.我只是想了解执行顺序.

public class One {

    public static void method() {
        System.out.println("in static one");
    }
}

public class Two {

    static One o;

    public static void main(String[] args) {
        o.method(); // expected NPE here, as o is null
    }
}

我知道静态方法应该用它们的类名调用,我甚至知道当我们用实例调用静态方法时IDE会给出编译器警告.但我们也可以通过创建一个实例来调用它们,但是,我从来没有在这里创建过一个实例,o应该得到它的默认值null,因此调用o.method()应该在运行时抛出一个NPE,但事实并非如此.你们能否详细说明这段代码中的执行顺序.

Class和Namespace都有？

这个问题是关于我看到自己越来越多地使用的模式:为相关概念提供类和命名空间.我认为这主要是由C++语言工件推动的,但并非完全如此.

我认为最高级别的问题是:这是个好主意吗？同时具有相关概念的类和命名空间？

较低级别的问题:

做这个的最好方式是什么？

嵌套在命名空间中的类？:

namespace Foo_Namespace {
   class Foo_Class {
       ...
   };
}

或者是单独的,对等的,类和命名空间？:

class Foo_Class {
    ...
};
namespace Foo_Namespace {
   // non-class free functions, etc.
}

我必须承认,我倾向于在命名空间中嵌套类.即使它导致丑陋的名字.但即使我这样做,我应该使用哪些命名约定:

以下内容太长,导致名称Foo_Namespace :: Foo_Class非常难看

namespace Foo_Namespace {
   class Foo_Class {
       ...
   };
}

没有必要在名称中使用任何后缀或指示符:

namespace Foo {
   class Foo {
       ...
   };
}

但是当我看到Foo :: bar()时,我发现自己不确定,如果它是namespace :: Foo中的自由函数栏,即:: Foo :: bar(),或者名称空间中的类Foo中的成员函数::富::富::酒吧().

像:: Foo :: Foo :: bar这样的名字仍然没有,嗯,很好.

目前我在做

没有必要在名称中使用任何后缀或指示符:

namespace Foo_ns {
   class Foo {
       ...
   };
}

主要是因为我通常先创建类,然后再认识到命名空间会很好.

我想知道是否应该恢复我多年来没有使用过的命名约定:_c用于类,_ns用于命名空间: …

我是Go的新手,我想知道如何在Java中实现类似于抽象类和方法的结构.在Java中,我会做以下事情:

abstract class A{

 static method1(){
  ...
  method2();
  ...
 }

 abstract method2();

}

class B extends A{

 method2(){
  ...
 }

}

class C extends A{

 method2(){
  ...
 }

}

我知道接口和结构.我可以构建一个接口,然后构建一个struct来实现method1.但是方法2怎么样？我知道我可以在另一个接口中嵌入一个接口,并将结构作为另一个结构的字段嵌入.但我没有看到用这些方法实现我的结构的方法.

我看到的唯一解决方案是在B类和C类中实现method1.还有其他方法吗？

注意:当然,在我的情况下,它不仅仅是一种方法.此外,我有一个抽象类的层次结构,并不真的想把所有内容都移到'子类'.

我在互联网上找到的例子主要是每个界面只有一种方法.如果你们其中一个人能给我一个提示,那就太棒了!谢谢.