类的每个实例中的引用类型属性如何保存Java中的最新实例

然而，在下面的Java代码中，类

TestRef

的每个实例中的

unSaved

属性如何保存最新的未保存对象

我试过了，TestRef类的每个实例的

unSaved

属性都包含unSaved，它调用

setUnSaved（）

设置为它，但我想实现它，它包含最新的unSaved（即最新的TestRef对象）

---

整个问题是通过使用静态变量（类变量）来解决的。为什么在每个对象实例中都保留对同一对象的引用。只需将此引用存储为类变量即可。为此，您必须做两件事：

将构造函数设为私有，以控制创建这些对象的人

将最新创建的实例保存在静态成员变量中（如果考虑多线程环境，则可能会同步该方法）

因此，您始终保留对最新创建的对象的引用。调整您的代码示例，您应该有如下内容：

package com.test.ref;

public class TestRef {
  private static TestRef unSaved;

  private String name;

  private TestRef(String name) {
    this.name = name;
    TestRef.unSaved = this;
  }

  public String getName() {
    return this.name;
  }

  public static TestRef getUnSaved() {
    return unSaved;
  }

  public void save() {
    System.out.println("save Finished");
  }

  public static void main(String[] args) {
    TestRef obj1 = new TestRef("obj1");
    TestRef obj2 = new TestRef("obj2");
    System.out.println(TestRef.unSaved.getName());
    System.out.println(obj1.getName());
    System.out.println(obj2.getName());
  }

}

---

整个问题是通过使用静态变量（类变量）来解决的。为什么在每个对象实例中都保留对同一对象的引用。只需将此引用存储为类变量即可。为此，您必须做两件事：

将构造函数设为私有，以控制创建这些对象的人

将最新创建的实例保存在静态成员变量中（如果考虑多线程环境，则可能会同步该方法）

因此，您始终保留对最新创建的对象的引用。调整您的代码示例，您应该有如下内容：

package com.test.ref;

public class TestRef {
  private static TestRef unSaved;

  private String name;

  private TestRef(String name) {
    this.name = name;
    TestRef.unSaved = this;
  }

  public String getName() {
    return this.name;
  }

  public static TestRef getUnSaved() {
    return unSaved;
  }

  public void save() {
    System.out.println("save Finished");
  }

  public static void main(String[] args) {
    TestRef obj1 = new TestRef("obj1");
    TestRef obj2 = new TestRef("obj2");
    System.out.println(TestRef.unSaved.getName());
    System.out.println(obj1.getName());
    System.out.println(obj2.getName());
  }

}

---

这个问题只涉及根据您的需求设计解决方案。您可以找到许多不同的实现方法

这里有一个例子。但你应该知道这可能不是一个好的设计

package com.test.ref;

import java.util.ArrayList;
import java.util.List;

public class TestRef {

    // TO ACCESS ALL INSTANCES OF TEST REF FOR UPDATE LATEST UNSAVED OBJECT REFENRECE
    private static List<TestRef> myObjList = new ArrayList<TestRef>();

    private TestRef unSaved;

    private String name;

    // GET OBJECT LIST TO CONSTRUCTOR
    public TestRef(String name, List<TestRef> myObjList) {
        this.name = name;

        // UPDATE ALL REFERENCES
        myObjList.add(this);
        for(TestRef myObj : myObjList)
        {
            myObj.setUnSaved(this);
        }
    }

    public String getName() {
        return name;
    }

    public TestRef getUnSaved() {
        return unSaved;
    }

    public void setUnSaved(TestRef unSaved) {
        this.unSaved = unSaved;
    }

    public void save() {
        System.out.println("save Finished");
    }

    public static void main(String[] args) {
        TestRef unSaved = null;

        TestRef obj1 = new TestRef("obj1", myObjList);

        unSaved = obj1;

        obj1.setUnSaved(unSaved);

        TestRef obj2 = new TestRef("obj2", myObjList);

        unSaved = obj2;

        // the unSaved in the obj1 is not reference to the newest obj(that is
        // obj2),How Can I achieve it?
        System.out.println(obj1.unSaved.getName());

        System.out.println(unSaved.getName());
    }
}

package com.test.ref；
导入java.util.ArrayList；
导入java.util.List；
公共类TestRef{
//为了更新最新的未保存对象REFENRECE而访问TEST REF的所有实例
私有静态列表myObjList=newarraylist（）；
私有TestRef未保存；
私有字符串名称；
//将对象列表获取给构造函数
公共TestRef（字符串名，列表）{
this.name=名称；
//更新所有引用
myObjList.add（这个）；
for（TestRef myObj:myObjList）
{
myObj.setunsave（这个）；
}
}
公共字符串getName（）{
返回名称；
}
公共TestRef getUnSaved（）{
未保存的返回；
}
public void setunsave（TestRef unsave）{
this.unsave=未保存；
}
公共作废保存（）{
System.out.println（“保存完成”）；
}
公共静态void main（字符串[]args）{
TestRef unsave=null；
TestRef obj1=新的TestRef（“obj1”，myObjList）；
未保存=obj1；
obj1.设置未保存（未保存）；
TestRef obj2=新的TestRef（“obj2”，myObjList）；
未保存=obj2；
//obj1中未保存的对象不是最新的obj（即
//obj2），我如何实现它？
System.out.println（obj1.unsave.getName（））；
System.out.println（未保存的.getName（））；
}
}

---

正如我提到的，这不是完美的解决方案。您可以阅读或阅读其他内容以获得更多想法。

此问题只涉及根据您的需求设计解决方案。您可以找到许多不同的实现方法

这里有一个例子。但你应该知道这可能不是一个好的设计

package com.test.ref;

import java.util.ArrayList;
import java.util.List;

public class TestRef {

    // TO ACCESS ALL INSTANCES OF TEST REF FOR UPDATE LATEST UNSAVED OBJECT REFENRECE
    private static List<TestRef> myObjList = new ArrayList<TestRef>();

    private TestRef unSaved;

    private String name;

    // GET OBJECT LIST TO CONSTRUCTOR
    public TestRef(String name, List<TestRef> myObjList) {
        this.name = name;

        // UPDATE ALL REFERENCES
        myObjList.add(this);
        for(TestRef myObj : myObjList)
        {
            myObj.setUnSaved(this);
        }
    }

    public String getName() {
        return name;
    }

    public TestRef getUnSaved() {
        return unSaved;
    }

    public void setUnSaved(TestRef unSaved) {
        this.unSaved = unSaved;
    }

    public void save() {
        System.out.println("save Finished");
    }

    public static void main(String[] args) {
        TestRef unSaved = null;

        TestRef obj1 = new TestRef("obj1", myObjList);

        unSaved = obj1;

        obj1.setUnSaved(unSaved);

        TestRef obj2 = new TestRef("obj2", myObjList);

        unSaved = obj2;

        // the unSaved in the obj1 is not reference to the newest obj(that is
        // obj2),How Can I achieve it?
        System.out.println(obj1.unSaved.getName());

        System.out.println(unSaved.getName());
    }
}

package com.test.ref；
导入java.util.ArrayList；
导入java.util.List；
公共类TestRef{
//为了更新最新的未保存对象REFENRECE而访问TEST REF的所有实例
私有静态列表myObjList=newarraylist（）；
私有TestRef未保存；
私有字符串名称；
//将对象列表获取给构造函数
公共TestRef（字符串名，列表）{
this.name=名称；
//更新所有引用
myObjList.add（这个）；
for（TestRef myObj:myObjList）
{
myObj.setunsave（这个）；
}
}
公共字符串getName（）{
返回名称；
}
公共TestRef getUnSaved（）{
未保存的返回；
}
public void setunsave（TestRef unsave）{
this.unsave=未保存；
}
公共作废保存（）{
System.out.println（“保存完成”）；
}
公共静态void main（字符串[]args）{
TestRef unsave=null；
TestRef obj1=新的TestRef（“obj1”，myObjList）；
未保存=obj1；
obj1.设置未保存（未保存）；
TestRef obj2=新的TestRef（“obj2”，myObjList）；
未保存=obj2；
//obj1中未保存的对象不是最新的obj（即
//obj2），我如何实现它？
System.out.println（obj1.unsave.getName（））；
System.out.println（未保存的.getName（））；
}
}

---

正如我提到的，这不是完美的解决方案。您可以阅读有关或其他内容以了解更多信息。

欢迎您。请在这里阅读本教程，它写得很好，是充分理解这些内容的良好起点：欢迎您。请在这里阅读本教程，它写得很好，是全面理解这些内容的良好起点：谢谢你的编辑。谢谢你的编辑。这个解决方案很糟糕。保留一个完整的对象列表会导致潜在的内存泄漏，因为这些引用不会被清除。此外，如果将引用作为私有静态变量保留，为什么必须将其传递给公共构造函数？对象已经有权访问其静态成员，而使用TestRef类的类则没有。将每个可能的实例都设置为同一个新对象有什么意义？@user3035281，您的代码中没有语法错误。您已经使用了。但是，