Java：双向组合示例

问题：

当你需要使用双向一对一构图时（在现实生活中）是否存在这种情况？什么时候表示A引用了B，B引用了相同的A对象

代码：

我该如何理解：

public class A {

    int val;
    private B b = new B(this);

    public A() {
        this.val = 10;
    }

    public void getAVal() {
        System.out.println("A val = " + val);
    }

    public void getBVal() {
        this.b.f();
    }

    public static void main(String[] args) {
        A a = new A();
        a.getAVal();  // echo 10
        a.getBVal(); // echo 0
    }
}
public class B {

    private A a;
    private int val;

    public B(A a) {
        this.a = a;
        this.val = a.val; //WRONG! A isn't constructed yet
    }

    public void f() {
        System.out.println("B val = " + this.val);
    }
}

---

p.S.如果在某些情况下确实需要它，请告诉它有什么程序和缺点。

这是一种非常常见的情况

例如，想象一下，如果一对夫妇已经结婚，那么一个阶级的丈夫和妻子就有了彼此的关系

优点是，从或类或其他你有参考的其他。您可以表示对象之间的所有关系，这样可以更轻松地导航对象

反对者通常会维持这些关系。由于每个关系都有两个端点，因此如果关系发生更改，则必须维护两个端点

---

出现这种情况的一个很好的常见情况是一个双链接列表，它同时引用了前面和后面的元素。

这是一个非常常见的情况

例如，想象一下，如果一对夫妇已经结婚，那么一个阶级的丈夫和妻子就有了彼此的关系

优点是，从或类或其他你有参考的其他。您可以表示对象之间的所有关系，这样可以更轻松地导航对象

反对者通常会维持这些关系。由于每个关系都有两个端点，因此如果关系发生更改，则必须维护两个端点

---

出现这种情况的一个很好的常见情况是一个双链接列表，它同时引用了前面和后面的元素。

这是一个非常常见的情况

例如，想象一下，如果一对夫妇已经结婚，那么一个阶级的丈夫和妻子就有了彼此的关系

优点是，从或类或其他你有参考的其他。您可以表示对象之间的所有关系，这样可以更轻松地导航对象

反对者通常会维持这些关系。由于每个关系都有两个端点，因此如果关系发生更改，则必须维护两个端点

---

出现这种情况的一个很好的常见情况是一个双链接列表，它同时引用了前面和后面的元素。

这是一个非常常见的情况

例如，想象一下，如果一对夫妇已经结婚，那么一个阶级的丈夫和妻子就有了彼此的关系

优点是，从或类或其他你有参考的其他。您可以表示对象之间的所有关系，这样可以更轻松地导航对象

反对者通常会维持这些关系。由于每个关系都有两个端点，因此如果关系发生更改，则必须维护两个端点

---

发生这种情况的一个很好的常见情况是一个双链接列表，它同时引用了前面和后面的元素。

尽管这是一个相当常见的结构，正如您正确指出的那样，存在许多固有的不稳定性，其中最重要的是如何整齐地破坏结构的问题

最常见的回避策略是将两个对象包装在处理程序中

public class C {
  private A a;
  private B b;

  public A getA () {
    return a;
  }

  public B getB () {
    return b;
  }

}

---

尽管这是一个相当常见的结构，正如您正确指出的，存在许多固有的不稳定性，其中最重要的是如何整齐地破坏结构的问题

最常见的回避策略是将两个对象包装在处理程序中

public class C {
  private A a;
  private B b;

  public A getA () {
    return a;
  }

  public B getB () {
    return b;
  }

}

---

尽管这是一个相当常见的结构，正如您正确指出的，存在许多固有的不稳定性，其中最重要的是如何整齐地破坏结构的问题

最常见的回避策略是将两个对象包装在处理程序中

public class C {
  private A a;
  private B b;

  public A getA () {
    return a;
  }

  public B getB () {
    return b;
  }

}

---

尽管这是一个相当常见的结构，正如您正确指出的，存在许多固有的不稳定性，其中最重要的是如何整齐地破坏结构的问题

最常见的回避策略是将两个对象包装在处理程序中

public class C {
  private A a;
  private B b;

  public A getA () {
    return a;
  }

  public B getB () {
    return b;
  }

}

---

---

@AnkitRustagi谁说他们在一个文件中？@AnkitRustagi谁说他们在一个文件中？@AnkitRustagi谁说他们在一个文件中？@AnkitRustagi谁说他们在一个文件中？是的，但是销毁呢？在我的例子中，我避免了这些麻烦，因为引用B只能通过对象访问。但如果你真的想要这种关系，你需要同时访问A和B。我同意Nickole的观点，单向关系不是一种关系，只要问问那些麦莉·赛勒斯的粉丝就可以了。在你的例子中，如果你不能从B访问A，因此没有利用B中引用A，那有什么意义？@Vakh，你是对的。但是，如果我在A&B类中适当地添加getB（）和getA（）方法，我将在销毁方面遇到一些问题，可能还有其他一些问题。这是我的缺点；-）您必须同时更新两个端点以避免出现非法状态是的，但是销毁如何？在我的例子中，我避免了这些麻烦，因为引用B只能通过对象访问。但如果你真的想要这种关系，你需要同时访问A和B。我同意Nickole的观点，单向关系不是一种关系，只要问问那些麦莉·赛勒斯的粉丝就可以了。在你的例子中，如果你不能从B访问A，因此没有利用B中引用A，那有什么意义？@Vakh，你是对的。但是，如果我在A&B类中适当地添加getB（）和getA（）方法，我将在销毁方面遇到一些问题，可能还有其他一些问题。这是我的缺点；-）您必须同时更新两个端点以避免出现非法状态是的，但是销毁如何？在我的例子中，我避免了这些麻烦，因为引用B只能通过对象访问。但如果你真的想要这种关系，你需要同时访问A和B。我同意Nickole的观点，单向关系不是一种关系，只要问问所有麦莉·赛勒斯的粉丝就可以了。在你的例子中，如果你不能从B访问A，那么