Java 为什么不是'；"；int-someVal=0“；对于被视为死代码的实例字段？

为什么在这里初始化

someVal

时没有死代码警告

public class DeadCode {

    private int someVal = 0;

    public DeadCode(int someVal) {
        this.someVal = someVal;
    }

    public int getSomeVal() {
        return someVal;
    }

    public void setSomeVal(int someVal) {
        this.someVal = someVal;
    }

}

Java编译器应该接收死代码并发出警告；但这是死了两次，并顺利通过

它死了两次，因为

Java自动将实例字段初始化为

0

或等效值

someVal

的值必须写入才能读取

我意识到，如果编译器愿意，它可以省略赋值，但是（根据定义）所有死代码都是这样

如果要区分死代码和无效代码，那么我希望

变量

someVal

的赋值无效

如果我写的话，我会得到什么

someVal = someVal;

在我的代码中。但我也不明白

---

在任何情况下，维基百科都认为删除了对程序结果没有影响的代码；这当然是一个例子。

整型字段是一个过于简单的用例。如果您有类似的内容，请注意无参数构造函数：

public class DeadCode {

    private List<Integer> someVal = new ArrayList<>();

    public DeadCode() {
    }

    public DeadCode(Iterable<Integer> someVal) {
        this.someVal.addAll(someVal);
    }

    public Iterable<Integer> getSomeVal() {
        return someVal;
    }

    public void addSomeVal(int someVal) {
        this.someVal.add(someVal);
    }
}

公共类死代码{
private List someVal=new ArrayList（）；
公共代码（）{
}
公共死码（Iterable someVal）{
this.someVal.addAll（someVal）；
}
公共Iterable getSomeVal（）{
返回某地；
}
公共void addSomeVal（int-someVal）{
this.someVal.add（someVal）；
}
}

---

您必须创建一个列表，是的，您可以在构造函数中创建。现在，编译器需要更加智能，以便能够确定在哪些情况下初始化字段是浪费时间的。我猜他们选择了一致和直接的行为。

整数字段是一个过于简单的用例。如果您有类似的内容，请注意无参数构造函数：

public class DeadCode {

    private List<Integer> someVal = new ArrayList<>();

    public DeadCode() {
    }

    public DeadCode(Iterable<Integer> someVal) {
        this.someVal.addAll(someVal);
    }

    public Iterable<Integer> getSomeVal() {
        return someVal;
    }

    public void addSomeVal(int someVal) {
        this.someVal.add(someVal);
    }
}

公共类死代码{
private List someVal=new ArrayList（）；
公共代码（）{
}
公共死码（Iterable someVal）{
this.someVal.addAll（someVal）；
}
公共Iterable getSomeVal（）{
返回某地；
}
公共void addSomeVal（int-someVal）{
this.someVal.add（someVal）；
}
}

---

您必须创建一个列表，是的，您可以在构造函数中创建。现在，编译器需要更加智能，以便能够确定在哪些情况下初始化字段是浪费时间的。我猜他们选择了一致和直接的行为。

整数字段是一个过于简单的用例。如果您有类似的内容，请注意无参数构造函数：

public class DeadCode {

    private List<Integer> someVal = new ArrayList<>();

    public DeadCode() {
    }

    public DeadCode(Iterable<Integer> someVal) {
        this.someVal.addAll(someVal);
    }

    public Iterable<Integer> getSomeVal() {
        return someVal;
    }

    public void addSomeVal(int someVal) {
        this.someVal.add(someVal);
    }
}

公共类死代码{
private List someVal=new ArrayList（）；
公共代码（）{
}
公共死码（Iterable someVal）{
this.someVal.addAll（someVal）；
}
公共Iterable getSomeVal（）{
返回某地；
}
公共void addSomeVal（int-someVal）{
this.someVal.add（someVal）；
}
}

---

您必须创建一个列表，是的，您可以在构造函数中创建。现在，编译器需要更加智能，以便能够确定在哪些情况下初始化字段是浪费时间的。我猜他们选择了一致和直接的行为。

整数字段是一个过于简单的用例。如果您有类似的内容，请注意无参数构造函数：

public class DeadCode {

    private List<Integer> someVal = new ArrayList<>();

    public DeadCode() {
    }

    public DeadCode(Iterable<Integer> someVal) {
        this.someVal.addAll(someVal);
    }

    public Iterable<Integer> getSomeVal() {
        return someVal;
    }

    public void addSomeVal(int someVal) {
        this.someVal.add(someVal);
    }
}

公共类死代码{
private List someVal=new ArrayList（）；
公共代码（）{
}
公共死码（Iterable someVal）{
this.someVal.addAll（someVal）；
}
公共Iterable getSomeVal（）{
返回某地；
}
公共void addSomeVal（int-someVal）{
this.someVal.add（someVal）；
}
}

---

您必须创建一个列表，是的，您可以在构造函数中创建。现在，编译器需要更加智能，以便能够确定在哪些情况下初始化字段是浪费时间的。我猜他们选择了一致和直截了当的行为。

我认为真正的答案是，许多人会发现警告代码非常烦人

---

不过，从技术上讲，初始值设定项并不构成死代码，因为原则上，它的效果可以在一个不正确同步的多线程程序中观察到。

我认为真正的答案是，许多人会发现该代码的警告非常烦人

---

不过，从技术上讲，初始值设定项并不构成死代码，因为原则上，它的效果可以在一个不正确同步的多线程程序中观察到。

我认为真正的答案是，许多人会发现该代码的警告非常烦人

---

不过，从技术上讲，初始值设定项并不构成死代码，因为原则上，它的效果可以在一个不正确同步的多线程程序中观察到。

我认为真正的答案是，许多人会发现该代码的警告非常烦人

---

---

但是，从技术上讲，初始值设定项并不构成死代码，因为原则上，它的效果可以在不正确同步的多线程程序中观察到。

冗余代码和死代码不一样。我看不到死代码。当编译器认为某些代码永远不会执行时，就会出现这种情况。您的示例只是两种不同的方法，您可以使用两种方法初始化实例参数并通过-fly@energizer不，那是无法访问的代码。死代码是没有效果的代码，这就是它。@azurefrog我已经更新了这个问题来解决这个问题。但是Wikipedia认为死代码消除就是这样，这正是问题所在。@至少在eclipse中，不可访问的代码是无法执行的代码（例如返回语句后的代码），而死代码是不会执行的代码（例如，

if（a）{if（！a）{//this is dead}

）。没有效果但将被执行的代码既不是不可访问的，也不是死的。Redun