java - 了解 Java 在用作方法参数时如何处理对象

Question

我一直在玩弄 Java，不太明白 java 方法如何处理传递给它们的对象。

例如，在下面的代码中，我创建了一些“容器”对象实例，其中包含另一个对象和一个基元。当我将这个“Container”对象传递给方法时，我可以更改保存在容器实例中的对象，要么直接修改它的值，要么使用 new 运算符构造一个新对象并替换其原始对象。这些更改是永久性的，因为它们的值是在方法外部检查时新对象的值。

让我非常困惑的是，虽然我可以通过方法更改 Containers 内部对象，但实际上我无法更改容器本身。我的意思是，如果我将容器传递给方法并尝试通过 new 运算符的交换或赋值来更改它。

下面是我用来测试修改对象实例属性然后修改实际实例本身的代码。

class InsideRef{
    char myChar;
    InsideRef(char newVal){
        myChar = newVal;
    }
}

class Container{
    InsideRef myInRef = null;
    int myPrimitive = 0;
    Container(char innerChar, int innerPrim){
        myInRef = new InsideRef(innerChar);
        this.myPrimitive = innerPrim;
    }
    public void myDetails(){
        System.out.format("Container.%s => myPrimitive -> %d || myInRef => %s -> %c.%n",
        this.hashCode(),this.myPrimitive,this.myInRef.hashCode(),this.myInRef.myChar);
    }
}

class AttribRefModder{
    public static void ModObjRefVal(Container toEdit){
        toEdit.myInRef.myChar = 'Z';
    }
    public static void ModNewObjReference(Container toEdit){
        toEdit.myInRef = new InsideRef('Y');
    }
}

class RefSwapper{
    public static void RefSwap(Container A, Container B){
        System.out.println("Swapping....");
        System.out.print("OBJECT A -> ");
        A.myDetails();
        System.out.print("OBJECT B -> ");
        B.myDetails();
        Container temp = A;
        A = B;
        B = temp;
        System.out.print("SWAPPED A -> ");
        A.myDetails();
        System.out.print("SWAPPED B -> ");
        B.myDetails();
        System.out.println("Exiting....");
    }
    public static void RefNew(Container A){
        System.out.println("Assigning Reference New Object....");
        A = new Container('V',999);
        System.out.print("NEW C REF -> ");
        A.myDetails();
        System.out.println("Exiting....");
    }
}

public class ReferenceModding{
    public static void main(String[] args){
        System.out.println("-----------MODDING INNER REFS----------");
        Container C1 = new Container('A', 111);
        System.out.print("ORIGINAL A -> ");
        C1.myDetails();
        AttribRefModder.ModObjRefVal(C1);
        System.out.print("MODDED A.Ref -> ");
        C1.myDetails();
        AttribRefModder.ModNewObjReference(C1);
        System.out.print("NEW A.Ref -> ");
        C1.myDetails();
        System.out.println("----------SWAPPING REFERENCES----------");
        Container C2 = new Container('B',222);
        RefSwapper.RefSwap(C1, C2);
        System.out.print("OBJECT A -> ");
        C1.myDetails();
        System.out.print("OBJECT B -> ");
        C2.myDetails();
        System.out.println("----------ASSIGN NEW OBJECTS----------");
        Container C3 = new Container('C',333);
        System.out.print("OBJECT C -> ");
        C3.myDetails();
        RefSwapper.RefNew(C3);
        System.out.print("OBJECT C -> ");
        C3.myDetails();
    }
}

如果我发布的代码过多，我深表歉意。只是我整天都在玩 Java，这个对象参数业务让我很困惑。我不明白为什么 Java 方法允许我编辑新对象并将其分配给容器类中保存的 InsideRef 引用，但不允许我对实际容器类执行相同的操作。

感谢您提供的任何帮助。

Answer 1

你已经正确地描述了 Java 的特性。

在幕后，您传递一个对象的引用——内存地址是一个很好的模型。因此，您可以更改该引用所引用的任何内容。

但是你不能改变调用者认为的“那个对象”——调用者有一个包含传递给你的地址的内存地址，你不能改变它。因此，无论您做什么，都无法更改所引用的对象，只能更改该对象“内部”的内容。