Java 如何将对象传递给类，以便当对象在类外更新时，它也会在类中过期？（爪哇）

我很难弄清楚如何在Java中通过引用传递。我目前有一门课，如下所示

class Example {
    ArrayList<Foo> list;
    Bar hello;

    Example(ArrayList<foo> list, Bar hello) {
        this.list = list;
        this.hello = hello;
    }
}

类示例{
数组列表；
酒吧你好；
示例（ArrayList列表，Bar hello）{
this.list=列表；
this.hello=你好；
}
}

在我的主类中，我初始化了一个Foo数组列表和一个Bar对象。然后初始化传入数组列表和Bar对象的示例。我想要的是，每当我传递给示例的对象在主类中更新时，它们也会在示例中更新。但目前，只有ArrayList被更新。但酒吧你好不是。是什么使ArrayList和它更新但Bar不更新的Bar不同

编辑

好的，这是实际代码的一部分：

public class Main {
    static int
            board_n = 1, // amount of boards
            rows = 8, // board width
            cols = 8; // board height
    static ArrayList<Board> boardlist;
    static Player player1 = new Player("Mr");
    static Player player2 = new Player("9000");
    static Player currentPlayer = player1;
    static Move dummy = null;

    public static void main(String[] args) {
        int random_row, random_col, random_board, rand_i;
        Dimension size = new Dimension(rows, cols);
        boardlist = new ArrayList(board_n);
        for(int i = 0; i < board_n; i++) {
            boardlist.add(new Board(i, size));
        }

        Rules rulez = new Rules(boardlist, dummy, currentPlayer);
        rulez.setPieces();

        Random generator = new Random();

        while(rulez.getPiecesAvailable("Checker", player1.getName()) > 0 || rulez.getPiecesAvailable("Checker", player2.getName()) > 0) {
                // initialize points and generate random location
                random_row = generator.nextInt(rows);
                random_col = generator.nextInt(cols);
                random_board = generator.nextInt(board_n);
                Point point = new Point(random_row, random_col);

                // initialize pieces and randomly set moveable
                Piece hello1 = new Checker(player1.getName(), Integer.toString(random_row), Integer.toString(random_col), Integer.toString(0), -1);
                Piece hello2 = new Checker(player2.getName(), Integer.toString(random_row), Integer.toString(random_col), Integer.toString(0), 1);

                // add piece to board
                if(rulez.validateAddition(new Location(point, random_board), hello1))
                    boardlist.get(random_board).addPiece(hello1, point);
                if(rulez.validateAddition(new Location(point, random_board), hello2))
                    boardlist.get(random_board).addPiece(hello2, point);
        }

        currentPlayer = player2;
    }
}

公共类主{
静态整数
线路板\u n=1，//线路板数量
行数=8，//板宽
cols=8；//板高
静态ArrayList董事会名单；
静态玩家player1=新玩家（“Mr”）；
静态玩家player2=新玩家（“9000”）；
静态播放器currentPlayer=player1；
静态移动虚拟=空；
公共静态void main（字符串[]args）{
int random_row，random_col，random_board，rand_i；
维度大小=新维度（行、列）；
boardlist=新阵列列表（board\n）；
对于（int i=0；i0 | | rulez.getPiecesAvailable（“Checker”，player2.getName（））>0）{
//初始化点并生成随机位置
random_row=生成器.nextInt（行）；
random_col=生成器nextInt（cols）；
随机板=生成器.nextInt（板n）；
点=新点（随机行、随机列）；
//初始化工件并随机设置为可移动
工件hello1=新棋盘格（player1.getName（），Integer.toString（随机行），Integer.toString（随机列），Integer.toString（0），-1）；
工件hello2=新棋盘格（player2.getName（），Integer.toString（随机行），Integer.toString（随机列），Integer.toString（随机列），Integer.toString（0），1）；
//添加一块到板上
if（规则Z.validateAddition（新位置（点，随机板），hello1））
boardlist.get（随机板）.addPiece（hello1，point）；
if（规则Z.validateAddition（新位置（点，随机板），hello2））
boardlist.get（random_board）.addPiece（hello2，point）；
}
currentPlayer=player2；
}
}

---

创建规则对象时，我将boardlist、dummy和currentPlayer传递给它。当我向董事会列表添加内容时，规则内部的董事会列表与外部的董事会列表相同。但是在最后一句话中，当我将currentPlayer更改为player2时，规则不会更改。

如果

Bar

不是一个基本类型，那么在类外对

Bar

所做的任何更改也会影响类内的

Bar

如果您试图通过将另一个对象重新指定给变量来更改

Bar

，则更改不会反映在您的类中。（我有一种感觉，在您的代码中可能就是这种情况）

但是，如果

Bar

是一种基本类型（int、double、char等），则您不能以现在的方式对其进行更改

解决方案

在您的这行代码中：

currentPlayer = player2;

您希望更改反映在您的类中。他们不会。您应该添加一个

changeCurrentPlayer（playerP）

方法，并在您的类中重新分配当前播放器

该方法的实现可能类似于：

public void changeCurrentPlayer(Player newPlayer){
    this.player = newPlayer;
}

---

如果

Bar

不是基本类型，则在您的类外对

Bar

所做的任何更改也会影响类内的

Bar

如果您试图通过将另一个对象重新指定给变量来更改

Bar

，则更改不会反映在您的类中。（我有一种感觉，在您的代码中可能就是这种情况）

但是，如果

Bar

是一种基本类型（int、double、char等），则您不能以现在的方式对其进行更改

解决方案

在您的这行代码中：

currentPlayer = player2;

您希望更改反映在您的类中。他们不会。您应该添加一个

changeCurrentPlayer（playerP）

方法，并在您的类中重新分配当前播放器

该方法的实现可能类似于：

public void changeCurrentPlayer(Player newPlayer){
    this.player = newPlayer;
}

---

如果看不到更多的代码，就无法确定，但我有一种预感，您的问题是在将

hello

传递给

Example

的构造函数后，您正在将它重新分配给另一个实例。对于

ArrayList

它之所以能像您所期望的那样工作，是因为您在同一

ArrayList

实例上调用方法，而从未重新分配实际的列表，这是传递给

Example

的构造函数的

编辑：

好的，现在我已经看到了您发布的实际代码，我看到我上面的预感是正确的。执行此操作时：

currentPlayer = player2;

您正在将currentPlayer分配给不同的实例。它不再指向传递给

Rules

构造函数的同一实例。你真正想做的事情更像这样：

rulez.setPlayer(player2);

 public void doNotDoThis(Bar hello) {
     hello = new Bar();
     hello.setFoo("new value"); // this won't be visible
 }

public void changePlayer(Player aPlayer)
{
    this.player = aPlayer;
}

public class Y
{
    public static void main(final String[] argv)
    {
        X x = new X(42);

       foo(x);
       System.out.println(x.getA());
    }

    private static void foo(final X x)
    {
        x.setA(7);
    }
}

public class Y
{
    public static void main(final String[] argv)
    {
        X x = new X(42);

       foo(x);
       System.out.println(x.getA());
    }

    private static void foo(X x)
    {
        x = new X(28);
        x.setA(7);
    }
}

---

当然，您的

规则

类需要定义一个

setPlayer（Player-Player）

方法才能工作。

如果没有看到更多的代码，就无法确定，但我有一种预感，您的问题是您正在将

hello

重新分配给另一个

public class Y
{
    public static void main(final String[] argv)
    {
        X x = new X(42);

       foo(x);
       System.out.println(x.getA());
    }

    private static void foo(final X x)
    {
        x.setA(7);
    }
}

public class Y
{
    public static void main(final String[] argv)
    {
        X x = new X(42);

       foo(x);
       System.out.println(x.getA());
    }

    private static void foo(X x)
    {
        x = new X(28);
        x.setA(7);
    }
}

currentPlayer = player2;

Rules rulez = new Rules(boardlist, dummy, currentPlayer);