java - 在被调用方法内分配一个对象，将其作为参数传递后，对调用方法没有任何影响

Question

我在修改或更像是传递给子方法的对象的分配时遇到问题。有一个 Cost 对象，它只有一些 double 变量来保存某些值。

public class Cost {
    double insertCost = 0;
    double deleteEleCost = 0;  

    private void addInsertCost(double cost) {
        insertCost += checkCost(cost);
    }

    private void addDeleteCost(double cost) {
        deleteEleCost += checkCost(cost);
    }

    public double getInsertCost() {
        return insertCost;
    }

    public double getDeleteCost() {
        return deleteEleCost;
    }

    public double getTotalCost() {
        return insertCost + deleteEleCost;
    }
}

在下面的 calcAverageCost() 完成后，Cost cost 的值始终为 0，尽管在 calcAverageCost() 方法中传递的 Cost 对象的值大于 0(计算得出):

private Cost handleCase1(Content content1, Content content2, Cost cost) {
    calcAverageCost(content1, content2, cost);
    System.out.println("insert: " + cost.getInsertCost());
    System.out.println("delete: " + cost.getDeleteCost());
    return cost;
}

在 calcAverageCost() 中，方法 getCost() 根据两个 Content 对象计算成本。例如，这些并不重要，问题是，两个 Contents 的每个方面的新 6 个单个 Cost 对象实际上在将它们放入 getCost() 后确实携带了 insertCost 和 deleteCost 的一些值。

这 6 个较小的 Cost 对象被合并为 3 个较大的 Cost 对象。即使那些值也符合预期。最后一步，getMinCost()(见末尾)返回具有最小成本值的一个 Cost 对象，并将其分配给新的 Cost 对象 FinalCost。然后，将这个对象赋值给上面传入的Cost对象(cost)。即使在这两个操作之后，修改后的双变量也可以很好地打印出 FinalCost 和 Cost cost。但是，当 calcAverageCost() 方法结束并且上面的 handleCase1() 方法继续时，传递的 Cost 成本再次只包含变量中的 0，就像 calcAverageCost() 中的更改期间没有发生任何事情一样。

根据我的理解，Java中应该有一个内部对象，它是getMinCost()方法的结果。通过将 FinalCost 分配给它，可以从该 Cost 对象指向该内部对象。通过对成本成本进行同样的操作，这个也应该指向那里。但不知何故，这种效果并没有延续到原始的调用者方法？我这里有什么误解吗？我认为这就像 Java 的工作方式。

我记得 Stackoverflow 上有一个气球线程，以及许多其他有关按值传递和 Java 的线程。通常我会尝试只阅读帖子，这是我第一次无法解决问题，所以我决定提出这个问题......

我真的很感激任何帮助，如果这个问题是一个坏问题，我很抱歉。

private void calcAverageCost(Content content1, Content content2, Cost cost){
    Cost min_min = new Cost();
    Cost min_max = new Cost();
    Cost avg_min = new Cost();
    Cost avg_max = new Cost();
    Cost max_min = new Cost();
    Cost max_max = new Cost();

    getCost(content1, content2,min_min);
    getCost(content1, content2,min_max);
    getCost(content1, content2,avg_min);
    getCost(content1, content2,avg_max);
    getCost(content1, content2,max_min);
    getCost(content1, content2,max_max);

    System.out.println("step1");
    printCost(min_min);
    printCost(min_max);
    printCost(avg_min);
    printCost(avg_max);
    printCost(max_min);
    printCost(max_max);
    //These one prints out nicely

    Cost s_min = new Cost();
    Cost s_avg = new Cost();
    Cost s_max = new Cost();

    s_min.addInsertCost((min_min.getInsertCost()+min_max.getInsertCost())/2d);
    s_min.addDeleteCost((min_min.getDeleteCost()+min_max.getDeleteCost())/2d);
    s_avg.addInsertCost((avg_min.getInsertCost()+avg_max.getInsertCost())/2d);
    s_avg.addDeleteCost((avg_min.getDeleteCost()+avg_max.getDeleteCost())/2d);
    s_max.addInsertCost((max_min.getInsertCost()+max_max.getInsertCost())/2d);
    s_max.addDeleteCost((max_min.getDeleteCost()+max_max.getDeleteCost())/2d);

    System.out.println("step2");
    printCost(s_min);
    printCost(s_avg);
    printCost(s_max);
    //These one prints out nicely as well

    Cost finalCost = getMinCost(getMinCost(s_min,s_avg),s_max);
    printCost(finalCost);
    //Also this one prints out nicely
    cost = finalCost;
    printCost(cost);
    //Even this one prints out nicely
}

这里是 getMinCost() 方法，它只是比较两个 Cost 对象并返回变量更好的一个

private Cost getMinCost(Cost cost1, Cost cost2) {
    Cost cost = cost1;
    System.out.println("cost1:"+cost1.getTotalCost());
    System.out.println("cost2:"+cost2.getTotalCost());
    if (cost1.getTotalCost() < cost2.getTotalCost()) {
        cost = cost1;
        System.out.println("cost1smaller");
    } else if (cost1.getTotalCost() > cost2.getTotalCost()) {
        cost = cost2;
        System.out.println("cost2smaller");
    } else if (cost1.getTotalCost() == cost2.getTotalCost()) {
        if (cost1.getDeleteCost() < cost2.getDeleteCost()) {
            cost = cost1;
            System.out.println("cost1delsmaller");
        } else if (cost1.getDeleteCost() > cost2.getDeleteCost()) {
            cost = cost2;
            System.out.println("cost2delsmaller");
        } else if (cost1.getDeleteCost() == cost2.getDeleteCost()) {
            cost = cost1;
            System.out.println("cost1deleq");
        }
    }
    System.out.println("cost:"+cost.getTotalCost());
    //shows correct result so far, the minimum cost
    return cost;
}

Answer 1

如果您想模仿“按引用传递”行为，为了修改输入成本，请使用持有者可变对象:

public class Holder<T> {
  private T value;
  public void setValue(T value) {this.value = value;}
  public T getValue() {return this.value;}
}

并且有:

private void calcAverageCost(Content content1, Content content2, Holder<Cost> holder) {
  ...
  holder.setValue(finalCost);
}

或者，因为只有一个参数需要更改:

private Cost calcAverageCost(Content content1, Content content2, final Cost cost) {
  ...
  return finalCost;
}

并使用调用代码的返回值。这会更好(您应该避免改变方法的参数)。