优雅的方式持有Java中的大型静态Aftyafe词典 - 或避免代码太大

StackOverflow https://stackoverflow.com/questions/864833

题

基本上，我想让一些词典对遗产节制 #define 指令。

我有一个包含6000多个定义的旧标头文件，用作标志参数函数，这些定义为表示一种类型的实体 parameter.

在C我有

  GetParameter(... , T_CTITLE, ...);

在Java我想打电话

  Connector.getParameter(Parameter.CTITLE, ...);

参数将封装与从库获取参数相关的所有逻辑。

参数实例自动从标题中提取并转换为Java代码，但问题是参数类变得太大 - 即我得到 code too large 编译错误（让我下划线：还有更多6000个参数）。

我很高兴能以一种能够使用自动完成的方式进行此类抽象，并且非常不喜欢将参数对象存储在Say中 HashMap.

编辑：参数类以以下方式定义：

public Parameter{
    /** logic **/
    public static final Parameter<T> parameter1 = new Parameter<T>("NAME", "T", 0xAAB);
    ...
    public static final Parameter<T> parameter6000 = new Parameter<T>("FOO", "T", 0xZZZ);
}
有帮助吗？

解决方案

一个明显的黑客将是分区成一个大的继承链，或者更好地分配到界面（不需要 public static final 噪声）和一个接口来继承它们。

您可以通过使创建代码较小来节省空间。代替：

new Parameter<T>("NAME", "T", 0xAAB)

极简主义的方法是：

parameter("NAME T AAB")

有关限制的详细信息，请参阅 第4.10节 JVM规格（第二版）。要查看您的编译代码是什么，请使用 javap -c.

其他提示

也许我不明白您想正确地做什么，但这看起来像是对我的枚举的完美用途。由于您可以在枚举中添加功能，只要您的Java版本足够最近（1.5+），他们应该能够完成您想要的工作。他们也序列化！

是的，它可以与Autocomplete一起使用，尽管6000列表很大。

我不知道枚举的大小是否有限制，但是您可以发现。

前任：

public enum Parameter {
    NAME("Pending", "T", 0xAAB), FOO("Foo", "T", 0x1FC);

    private final String displayValue;
    private final char myChar;
    private final int someNum;

    private Parameter(String display, char c, int num) {
        this.displayValue = display;
        this.myChar = c;
        this.someNum = num;
    }

    public String getDisplayValue() {
        return displayValue;
    }

    public char getMyChar() {
        return myChar;
    }

    public int getSomeNum() {
        return someNum;
    }
}

现在，这使您可以做自己想做的事情。前任：

System.out.println("Hi, the value is " + Parameter.NAME.getSomeNum());

由于它们在运行时不会改变（毕竟#Defines不能），因此枚举应该适合该账单。

至于纯尺寸，您可能会尝试将它们稍微搭配，并将它们放入几个枚举组中。

这使您能够将元数据（数字），自动完成，==等相关联。

基本上，我认为多个接口方法是必经之路。这是我将如何构建该解决方案的方式；我不知道您的参数构造函数的第二个论点是什么意思，所以我忽略了它。

在.../com/yourcompany/legacyDefines/parameter.java：

package com.yourcompany.legacydefines;

public class Parameter<T> {
  private final String name;
  private final T val;

  private Parameter(String name, T val) {
    this.val = val;
    this.name = name;
  }

  public static <T> Parameter<T> newParameter(String name, T val) {
    return new Parameter<T>(name, val);
  }

  // then, standard getters for "name" and "val"
}

在.../com/yourcompany/legacyDefines/parameters1.java：

package com.yourcompany.legacydefines;

import static com.yourcompany.legacydefines.Parameter.newParameter;

interface Parameters1 {
  public static Parameter<String> Parameter0001 = newParameter("ABC", "ABCVAL");
  // ...
  public static Parameter<Integer> Parameter0999 = newParameter("FOO", 0xABCD);
}

在.../com/yourcompany/legacyDefines/parameters2.java：

package com.yourcompany.legacydefines;

import static com.yourcompany.legacydefines.Parameter.newParameter;

interface Parameters2 {
  public static Parameter<String> Parameter1001 = newParameter("DEF", "DEFVAL");
  // ...
  public static Parameter<Integer> Parameter1999 = newParameter("BAR", 0x1002);
}

（等等）

在.../com/yourcompany/legacyDefines/parameters.java：

package com.yourcompany.legacydefines;

interface Parameters extends Parameters1, Parameters2, Parameters3, Parameters4,
                             Parameters5, Parameters6, Parameters7 {}

然后，在您的其他代码中，只需使用参数。Parameter4562

在汤姆·霍顿（Tom Hawtin）的帖子上扩展，请考虑使用JSON编码结构。

或者更好的是，将它们放入XML或JSON文件（或属性文件）中，而不是用硬编码参数，该参数被吸引到最终产生的任何JAR文件中。

我认为这就是您想要的。我想，“ t”是类型，您想使用仿制药，以便用户不必施放#Define值：

public class Parameter<T> {

    public final static Parameter<String> NAME = new Parameter<String>("hello");
    // .. 5998 more declarations
    public final static Parameter<Integer> FOO = new Parameter<Integer>(0xff0b);


    private T value;
    private Parameter(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }   
}

要访问参数，只需致电：

String value = Parameter.NAME.getValue();

Java常数等于#Defines名称，通用性反映了类型，因此我们只需要将值传递给构造函数即可。代码完成正常:)

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top