标签: static-methods

我的解释是,如果我需要静态访问一个方法,我应该只在我不需要实例化时才使该类成为抽象.真的吗？

我正在重构一些代码,我正在看一个名为HFile的类.HFile具有所有私有构造函数,因此您无法实际创建它的实例.而不是如下创建HFiles的实例:

var file = new HFile('filename')
file.Save()

所有HFile交互都是通过静态方法处理的.所以,如果我想保存文件,我会打电话:

HFile.save('filename')

然后在内部创建一个HFile实例然后保存.显然,在不了解整个故事的情况下,任何读者都必须保留判断力,但似乎使用静态方法在我的工作场所变得非常流行.所以我想知道静态方法的使用是否有良好的原则/最佳实践,可以帮助一群人坐下来回顾他们对静态方法的使用.

我有一个在Tomcat上运行的Web应用程序.

需要在Web应用程序的多个位置进行多项计算.我可以将这些计算用于静态辅助函数吗？如果服务器有足够的处理器内核,那么对该静态函数的多次调用(由多个不同servlet的请求产生)是否可以并行运行？或者一个请求是否必须等到另一个请求完成呼叫？

public class Helper {
    public static void doSomething(int arg1, int arg2) {
        // do something with the args
        return val;
    }
}

如果调用并行运行:我有另一个带有静态函数的辅助类,但是这个类包含一个静态函数中使用的私有静态成员.如何确保函数是线程安全的？

public class Helper {

    private static SomeObject obj;

    public static void changeMember() {
        Helper.obj.changeValue();
    }

    public static String readMember() {
        Helper.obj.readValue();
    }

}

changeValue()并readValue()读取/更改相同的成员变量Helper.obj.我是否必须使整个静态函数同步,或者只是Helper.obj使用哪个块？如果我应该使用一个块,我应该使用什么对象来锁定它？

class TConst
{
    const int i;
    int& ref;
    public:
    TConst(int n):i(n),ref(n){}
    static void p1(){prn(i);}//error here
};

当我尝试const在static成员函数中使用类成员时,我的编译器会生成错误.

为什么不允许？

我有一个像这样的Java类:

public class Foo {

    public static int counter = 0;

    public void bar(int counter) {
        Foo.counter = counter;
    }
}

FindBugs警告我counter通过实例方法写入静态字段bar.但是,如果我将代码更改为:

public class Foo {

    public static int counter = 0;

    public static void setCounter(int counter) {
        Foo.counter = counter;
    }

    public void bar(int counter) {
        setCounter(counter);
    }
}

然后FindBugs不会抱怨.这不是错的吗？我仍然通过静态方法从实例方法写入静态字段,不是吗？

我protected在搜索我的问题的解决方案时发现了使用修饰符:忽略带有单元的反射词组件ReflectionComparator

在org.unitils.reflectionassert.ReflectionComparatorFactory课堂上有签名的方法:

protected static List<Comparator> getComparatorChain(Set<ReflectionComparatorMode> modes)

但这只是特殊情况.

毕竟我们总是可以扩展这样的任何非final类,并protected使用new public修饰符"覆盖"它的静态方法.说,我们有课A:

public class A {
    protected static void test() {
        // do some stuff
    }
}

并希望在另一个包中使用它:

public class UseA {
    private static class MyA extends A {
        public static void test() {
            A.test();
        }
    }

    void useA() {
        // A.test(); compile error, sure
        MyA.test();
    }
}

当某些static方法被宣布为时,我将我的问题集中在一般情况上protected.我不是在询问非静态字段或方法,因为在某些情况下,类可以具有私有构造函数或具有许多特殊参数的非常复杂的构造函数.但是如果整个班级不是这样的"隐藏"静态方法的目的是什么final？这种用法是错误还是只是非常弱的"保护"？

以下是我的代码段的两行:

List<String> listDevs = Arrays.asList("alvin", "Alchemist", "brutus", "larsen", "jason", "Kevin");

listDevs.sort(Comparator.comparing(String::length)); //This works fine
listDevs.sort(String::compareToIgnoreCase); //This works fine

但是(当expermient)当我尝试写

listDevs.sort(Comparator.comparing(String::compareToIgnoreCase));

编译器抛出错误

无法从类型String中对非静态方法compareToIgnoreCase(String)进行静态引用

类似的情况发生在下面的代码中

listDevs.sort(Comparator.comparing(String::compareTo));

我理解错误,如果我删除Comparator.comparing(如上所示)它工作正常.

但我的观点是,这条线如何运作？

listDevs.sort(Comparator.comparing(字符串::长度));

我相信我错过了一些东西.我已经读过这个帖子了.这是同样的情况吗？

在使用解析属性时__dict__,我@staticmethod不是callable.

Python 2.7.5 (default, Aug 29 2016, 10:12:21)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from __future__ import (absolute_import, division, print_function)
>>> class C(object):
...   @staticmethod
...   def foo():
...     for name, val in C.__dict__.items():
...       if name[:2] != '__':
...          print(name, callable(val), type(val))
...
>>> C.foo()
foo  False  <type 'staticmethod'>

• 这怎么可能？
• 如何检查静态方法是否可调用？

我在下面提供了一个更详细的例子:

脚本 test.py

from __future__ import (absolute_import, division, print_function)

class …

我理解这__new__是一个静态方法,super()可以从它调用创建一个新对象,如下所示:

>>> class A:
...     def __new__(cls):
...         print('__new__ called')
...         return super().__new__(cls)
...
>>> a = A()
__new__ called

为什么super调用不能与其他静态方法一起使用？为什么以下失败？

>>> class B:
...     @staticmethod
...     def funcB():
...         print('funcB called')
...
>>> class C(B):
...     @staticmethod
...     def funcC():
...         print('funcC called')
...         super().funcB()
...
>>> c = C()
>>> c.funcC()
funcC called
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in funcC
RuntimeError: super(): …

我正在阅读一篇关于nullptrC++ 中一些特性的文章，一个特定的例子在我的理解中引起了一些混乱。

考虑（来自上述帖子的简化示例）：

struct A {   
    void non_static_mem_fn() {}  
    static void static_mem_fn() {}  
};


A* p{nullptr};

/*1*/ *p;
/*6*/ p->non_static_mem_fn();
/*7*/ p->static_mem_fn();

根据作者的说法/*1*/，取消引用 the 的表达式nullptr本身不会导致未定义的行为。与/*7*/使用nullptr-object 调用静态函数的表达式相同。

理由基于C++ Standard Core Language Closed Issues, Revision 100中的issue 315

... *pis not an error when pis null 除非左值被转换为右值（7.1 [conv.lval]），它不在这里。

从而区分/*6*/和/*7*/。

因此，对实际的间接引用nullptr 不是未定义行为（在SO答案，在C ++标准的问题232讨论，...）。因此，/*1*/在这个假设下， 的有效性是可以理解的。

但是，如何 …