标签: static-members

Java中的静态枚举和非静态枚举有什么区别？两种用法都是一样的.

这是正确的吗？ 所有静态的都在启动时加载到内存中,非静态的是按需加载的？ 如果是,那么哪种方法更好？是否始终将一些数据保存在内存中或使用服务器资源加载它们？

public class Test {

    public enum Enum1 {
        A, B
    }

    public static enum Enum2 {
        C, D
    }

    public static void main(String[] args) {
        Enum1 a = Enum1.A;
        Enum1 b = Enum1.B;

        Enum2 c = Enum2.C;
        Enum2 d = Enum2.D;
    }
}

我在几个旧项目中看到过这样的代码:

class Class {
    static void Method() {}
};

((Class*)0)->Method();

此代码包含未定义的行为,因为它包括取消引用空指针(无论之后发生什么).这真的没有意义 - 演员是在那里将类型名称提供给编译器,并且编写上面代码的人可以写这个:

Class::Method();

而后者也没关系.

为什么有人会写前代码？它是来自一些美好时光的已知成语还是什么？

说你有课,

class Foo
{
    public static bar;
}

当你说:

new Foo();

我可以想象,在内存中,为这个对象保留了一个空间.

......当你再说一次时:

new Foo(); 

...现在你有另一个可用于该物体的空间.

但是,静态场的确切位置在哪里？

我真正想要学习的是:

对象的引用如何引用它们引用的对象的相同字段？

我对这件事情有点困惑.我正在设计一个ORM类,它试图在ruby on rails上与ActiveRecord非常相似,但这不是重点.

我想说的是我的类广泛使用静态属性继承,特别是对数据库和表处理.我的问题是,我应该使用self ::

我知道你可以 间接定义它们 与同伴对象实现类似的东西,但我想知道为什么语言设计是从类定义中删除静态.

我只是注意到staticSwift的成员structs是含蓄的lazy.

例如,这只会调用init一次:

class Baz {
    init(){
        print("initializing a Baz")
    }
}
struct Foo {
    static let bar = Baz()
}

var z = Foo.bar
z = Foo.bar

这背后的理由是什么？

如果我想要相反的行为怎么办？

在非模板库类中拥有静态成员的最佳方法是什么,而不必在类用户上承担定义成员的负担？

说我想提供这个课程:

class i_want_a_static_member
{
    static expensive_resource static_resource_;

public:
    void foo()
    {
        static_resource_.bar();
    }
};

那么类的用户一定不要忘了某处定义静态成员(如已经回答了 很多 次):

// this must be done somewhere in a translation unit
expensive_resource i_want_a_static_member::static_resource_;

我在下面有一个答案,但它有一些缺点.是否有更好和/或更优雅的解决方案？

静态成员变量是否会被垃圾收集？

例如,让我们使用以下类.

public class HasStatic {
    private static List<string> shared = new List<string>();

}

并且假设它像这样使用:

//Startup
{
HasStatic a = new HasStatic();
HasStatic b = new HasStatic();
HasStatic c = new HasStatic();
HasStatic d = new HasStatic();
//Something
}
//Other code
//Things deep GC somewhere in here
HasStatic e = new HasStatic();

当a,b和c,以及d垃圾收集时,静态成员是否也shared被收集？可能e会得到一个新的实例shared？

我发现自己不会有私人课程.如果可能的话,所有候选私有类函数,而不是我放入未命名的命名空间,并将所有必要的信息作为函数参数传递.我没有一个合理的解释,为什么我这样做,但至少它对我来说更自然.因此,我需要在头文件中公开更少的内部细节.

你有什么看法 - 这是正确的做法吗？

我正在尝试将以下Objective-C代码转换为Swift.在我的Objective-C代码中,有一个静态变量,它可以从类方法访问.

@implementation SomeClass

static NSMutableArray *_items;

+ (void)someMethod {
    [_items removeAll];
}

@end

因为你无法private var items = [AnyObject]()从Swift中的类函数访问这样声明的类型,所以我为它创建了一个存储属性.

class var items: [AnyObject] {
    return [AnyObject]()
}

而我正试图从类函数中调用一个方法.

class func someFunction() {
    items.removeAll(keepCapacity: false)
}

但我得到这个错误类型'[AnyObject]'的不可变值只有名为'removeAll'的变异成员.

任何人都可以告诉我这个错误的原因是什么以及如何纠正它？

谢谢.