0

我正在创建许多常量，每个常量都有一些唯一命名的公共常量字段。这是我正在尝试做的，但由于下面示例中的 T1 是一个匿名类，因此无法编译。

public class Templates {

    public static class Template {}

    public static final Template T1 = new Template(){

        public final String NAME = "My Name";
    };

    public static final Template T2 = new Template(){

        public final String THING1 = "This is a thing.";
        public final String THING2 = "This is another thing.";
    };

    public static void main(String[] args){
        System.out.println(T1.NAME); // does not compile
    }
}

我正在寻找某种方法来完成上述工作或一些好的替代方法。每个模板将有不同数量的具有不同名称的常量。任何帮助表示赞赏！

到目前为止，我发现的最佳替代方案是使用单例设计模式，但如果有人知道代码密集程度较低的方法，我很想知道。

4

4 回答 4

0

参考这篇博文，枚举是简单的静态最终类。唯一的区别是不必写：

public class Direction extends java.lang.Enum{
    public final static Direction NORTH;
    ...

    static{
        NORTH = new Direction("NORTH", 0);
        ...

        VALUES = new Direction[(size here)];
        VALUES[0] = NORTH;
        ...
    }
} // taken from the referred blogpost

您只需编写一行代码：enum Direction{}并获得上述所有内容。

这意味着您可以像处理类一样处理枚举。

您可以向枚举添加任意方法：

public enum TestEnums {
    TEST_ENUM_1;

    void doSomething(){
         System.out.print("I'm a method in enum");
    }
}
TestEnums.TEST_ENUM_1.doSomething(); //to call the method

您可以将字段添加到枚举：

public enum TestEnums {
    TEST_ENUM_1;

    String message = "I'm a field in enum";

    void doSomething(){
         System.out.print(message);
    }
}

您可以在枚举中使用构造函数：

public enum TestEnums {
    TEST_ENUM_1("I'm a field in enum 1"),
    TEST_ENUM_2("I'm a field in enum 2");

    String message;

    TestEnums(String message){
        this.message = message;
    }

    void doSomething(){
         System.out.print(message);
    }
}

您可以使枚​​举实现接口：

public enum TestEnums implements IEnum{
    TEST_ENUM_1("I'm a field in enum 1");

    String message;

    TestEnums(String message){
        this.message = message;
    }

    public void doSomething(){
         System.out.print(message);
    }
}

interface IEnum{
    void doSomething();
}

但请记住，您不能扩展枚举，因为它们是最终的。

有了这一切，您可以使用组、字段和方法实现您想要的行为，免费获得单例和编译器检查。使用枚举接口还可以让您轻松扩展枚举提供的操作数量或使用不同的类。

于 2013-09-07T12:18:14.600 回答
0

我不知道你为什么要这样做，但匿名类是一个不同的类，它扩展了用 new 关键字声明的类。

喜欢

Template T1 = new Template(){

    public final String NAME = "My Name";
};

创建的新类不是模板，而是扩展模板的类。该扩展类的 Name 变量不在 Template 类中

并且 T1 只能看到其变量或其父变量，但看不到或无法获得有关其子变量的信息。

于 2013-09-05T22:33:12.340 回答
0

如果你必须使用匿名类而不是你需要在模板中声明变量并从匿名类初始化它们，它很丑但可能：-

class Templates {

public static class Template {

    public String Name;
    public String THING1;
    public String THING2;
}


public static final Template T1 = new Template() {

    {
        Name = "My Name";
    }
};

public static final Template T2 = new Template() {
    {
        THING1 = "This is a thing.";
        THING2 = "This is another thing.";
    }


};

public static void main(String[] args) {
    System.out.println(T1.Name); // compiles now
}
}
于 2013-09-05T22:39:39.023 回答
0

实际上，与您打算做的最接近的事情是定义内部类或-更好的接口。如果定义类，则需要将类成员设置为静态。

public class Templates {


    public static interface T1 {

        public final static String NAME = "My Name";
    };

    public static interface T2{

        public final String THING1 = "This is a thing.";
        public final String THING2 = "This is another thing.";
    };

    public static void main(String[] args){
        System.out.println(T1.NAME); // DOES compile
    }
}

顺便说一句，您也可以用枚举替换它们，而不是使用字符串常量。

于 2013-09-06T16:29:55.717 回答