相关疑难解决方法(0)

据我所知,"静态初始化块"用于设置静态字段的值,如果不能在一行中完成的话.

但我不明白为什么我们需要一个特殊的块.例如,我们将一个字段声明为静态(没有值赋值).然后编写几行代码,生成并为上面声明的静态字段赋值.

为什么我们需要在一个特殊的块这样的行这样的:static {...}？

我正在寻找一些开源Java项目来进入Java,并注意到它们中有很多都有某种"常量"接口.

例如,processing.org有一个名为PConstants.java的接口,大多数其他核心类实现了这个接口.界面充满了静态成员.有这种方法的理由,还是这被认为是不好的做法？为什么不在有意义的地方使用枚举,或者使用静态类？

我发现使用接口允许某种伪"全局变量"很奇怪.

public interface PConstants {

  // LOTS OF static fields...

  static public final int SHINE = 31;

  // emissive (by default kept black)
  static public final int ER = 32;
  static public final int EG = 33;
  static public final int EB = 34;

  // has this vertex been lit yet
  static public final int BEEN_LIT = 35;

  static public final int VERTEX_FIELD_COUNT = 36;


  // renderers known to processing.core

  static final …

我有这样的枚举:

public enum PcapLinkType {
  DLT_NULL(0)
  DLT_EN10MB(1)
  DLT_EN3MB(2),
  DLT_AX25(3),
  /*snip, 200 more enums, not always consecutive.*/
  DLT_UNKNOWN(-1);
    private final int value;   

    PcapLinkType(int value) {
        this.value= value;
    }
}

现在我从外部输入得到一个int并想要匹配的输入 - 如果一个值不存在就抛出一个异常是好的,但最好是DLT_UNKNOWN 在这种情况下我会有.

int val = in.readInt();
PcapLinkType type = ???; /*convert val to a PcapLinkType */

我开始用Java编程,我想知道是否#define存在与C++相当的东西.

谷歌的快速搜索说它没有,但任何人都可以告诉我,如果Java中存在类似的东西吗？我正在努力让我的代码更具可读性.

而不是myArray[0]我想能够写myArray[PROTEINS]例如.

在Java中使用标志时,我看到了两种主要方法.一个使用int值和一行if-else语句.另一种是使用枚举和case-switch语句.

我想知道在使用enums和ints for flags之间内存使用和速度方面是否存在差异？

我试图理解Java枚举是如何工作的,我得出的结论是它与普通的Java类非常相似,它的构造函数被声明为private.

我刚刚得出这个结论,并不是基于太多的想法,但我想知道我是否想念任何东西.

下面是一个简单的Java枚举和一个等效的Java类的实现.

public enum Direction {
    ENUM_UP(0, -1),
    ENUM_DOWN(0, 1),
    ENUM_RIGHT(1, 0),
    ENUM_LEFT(-1, 0);


    private int x;
    private int y;

    private Direction(int x, int y){
        this.x = x;
        this.y = y;
    }
    public int getEnumX(){
        return x;
    }
    public int getEnumY(){
        return y;
    }
}

上面和下面的代码有什么区别？

public class Direction{
    public static final Direction UP = new Direction(0, -1) ;
    public static final Direction DOWN = new Direction(0, 1) ;
    public static final Direction LEFT = new Direction(-1, 0) ; …

可以在运行时从Java中的枚举中添加和删除元素吗？

例如,我可以从文件中读取枚举的标签和构造函数参数吗？

@saua,这只是一个问题,它是否真的可以完成.我希望有一些改变运行字节码的巧妙方法,可能使用BCEL或其他东西.我也跟进了这个问题因为我意识到我不确定何时应该使用枚举.

我非常确信,如果我希望能够在运行时安全地更改内容,那么正确的答案是使用一个确保唯一性而不是枚举的集合.

对实用程序类来说,常见的做法是为它们提供一个私有构造函数:

public final class UtilClass {
    private UtilClass() {}

    ...
}

但不幸的是,有些工具不喜欢私有构造函数.他们可能会警告它在类中没有被调用,它没有被测试覆盖,块不包含注释等.

如果您这样做,很多警告就会消失:

public enum UtilClass {;
    ...
}

我的问题是:除了对未来开发人员的无休止的仇恨之外,没有值的枚举和Java中的私有构造函数的类之间有什么重要的区别？

请注意,我并不是说Java枚举与具有公共静态最终字段的类相比有什么优势？.我不是在决定一系列事物应该是一堆常量还是一个枚举,我决定将一堆函数放在无构造函数的类或无值的枚举中.

另请注意,我实际上并不想这样做.我只想知道权衡作为一般语言知识的一部分.

例如,使用枚举会使用无用的方法污染自动完成UtilClass.values().还有哪些缺点？上升空间？

将Java中的枚举类似于类,而不仅仅是C/C++中的常量集合有什么好处？

我正在尝试阅读枚举以更好地理解它们.

从枚举的javadocs我得到以下内容:

枚举类型是一种特殊的数据类型,它使变量成为一组预定义的常量.

对我来说,这听起来很像一个final变量.

1. 真正的区别是什么？
2. 你什么时候用一个而不是另一个？
3. 枚举只是一个可以成为一组事物的最终变量吗？

我知道 enum 在 java 中的用法。

是否建议使用枚举来存储程序常量（而不是下面描述的类）？

public class Constants{
    public static final String DB_CF_NAME = "agent";
    public static final String DB_CF_ID = "agent_id";
    public static final String DB_CF_TEXT = "agent_text";
    public static final String DB_CF_LATITUDE = "latitude";
}

在定义谓词或函数时,我曾经将它们创建为static final

private static final Predicate<SomeDto> SOME_PREDICATE =
                new Predicate<SomeDto>() {
                    @Override
                    public boolean apply(SomeDto input) {
                        return input.isValid();
                    }
                }

但是我注意到,enum例如,版本也有很多用途

private enum SomePredicate implements Predicate<SomeDto> {
        INSTANCE;

        @Override
        public boolean apply(SomeDto input) {
            return input.isValid();
        }
    }

我知道枚举与静态最终主题,但是使用枚举对谓词或函数的静态最终是否有任何真正的优势？