与建筑商的最后障碍

Question

我有一个使用构建器（J Bloch 风格）的图（g）。需要反转图表才能运行某些统计数据，然后将其缓存以供报告和分析算法访问。

因此，图 g 定义了以下参考变量：

private final Builder savedBuilder; // save builder for clone build with same properties.
private final Graph   gPrime;       // must reverse populated graphs BEFORE cache of stats

注意：gPrime 指的是一个相同的图，只不过它是由反转的 g 填充的。 gPrime.gPrime 应该引用 g，因为 g 是 gPrime 的逆向。

和构建器构建方法：

public Graph build() {
  Graph g = new Graph(this);
  g.gPrime.gPrime = g;
  return g;
}

以及采用构建器的构造函数：

private Graph (Builder builder){  // 'this' used for clarity
  this.gType        = builder.gType;
  this.dropOrphans  = builder.dropOrphans;
  this.fileHandle   = builder.fileHandle;       
  this.nodes        = builder.nodes;            
  this.edges        = builder.edges;            
  this.delimiter    = builder.delimiter;
  this.mapCapacity  = builder.mapCapacity;       
  this.mapLoadFactor    = builder.mapLoadFactor;
  this.savedBuilder = builder;  // save builder for cloning

  emptyGraph();     // build empty structure for data in this graph
  if (this.fileHandle == null) {           // no file data
    if (this.nodes == 0) {         // no sizing info
    ;                  // nothing else to do - - - empty graph
    } else {                    // we have # of nodes
      if ( this.edges == 0) {            // just an edge-less integer graph)
      populateEdgeless(nodes)   ;
      } else {                 // randomly generated graph
    populateRandom(nodes, edges);
      }
    }
  } else {                 // populate from file
    populateFromFile();
  }

  // To create empty graph to transpose our values into,
  // we need to clear out builder settings that would populate a new graph.
  savedBuilder.fileHandle = null;
  savedBuilder.nodes = 0;
  savedBuilder.edges = 0;

  // otherwise, everything the same, so just pass modified builder to constructor
  // save the reference to this graph ( ready for the reversal method to use )
  this.gPrime = new Graph(savedBuilder);

)

再次。目标是两个图形对象，每个对象中的 gPrime 都引用另一个对象。

顺序是： 构建 g - - - 填充 g - - - 将 g 反转为与 g 具有相同特征的空图

所以，这是我不太明白的问题。

如果我将 g 分配给 gPrime.gPrime，无论是在 g 我们构建之后的构建中还是在构造函数的底部，我都会收到一条错误消息，指出 gPrime 是最终的。 Eclipse 表明这是第一个有问题的 gPrime - - - 这是真的 - - - 它是最终的并且已被分配。但 gPrime.gprime （重点是第二个 gPrime ）尚未分配。 （我搜索了整个程序。）

我还尝试将作业放在反向方法的底部。同样的事情。

我还在构建器中尝试了 g.gPrime.gPrime 。同样的事情。

就好像编译器对哪个 gPrime 正在接收分配感到困惑。

我确信有些东西我没有看到或理解 - - - 但是 - - - 不知道如何实现这一点。

如果我拿出决赛，我就能完成这项工作，但我正在努力做到一成不变。

Answer 1

您需要不可变的循环依赖项。您必须实现它，以便当您构建A（在A的构造函数中）时，您必须使用调用B的构造函数 >这个。

下面是Builders的代码（你必须确保整个构建过程不会从当前线程中逃逸）：

public class A {

  private final B b_;
  private final String name_;

  private A(Builder b) {
    b_ = b.bB_.a(this).build();
    name_ = b.name_;
  }

  public String name() {
    return name_;
  }

  public B b() {
    return b_;
  }

  @Override
  public String toString() {
    return "[" + name_ + ": " + b_.name() + " ]";
  }

  public static class Builder {

    private B.Builder bB_;
    private String name_;

    public Builder bB(B.Builder bB) {
      bB_ = bB;
      return this;
    }

    public Builder name(String arg) {
      name_ = arg;
      return this;

    }

    public A build() {
      return new A(this);
    }
  }

}

B类：

public class B {

  private final A a_;
  private final String name_;

  private B(Builder b) {
    a_ = b.a_;
    name_ = b.name_;
  }

  public String name() {
    return name_;
  }

  @Override
  public String toString() {
    return "[" + name_ + ": " + a_.name() + " ]";
  }

  public static class Builder {

    private A a_;
    private String name_;

    public Builder a(A a) {
      a_ = a;
      return this;

    }

    public Builder name(String arg) {
      name_ = arg;
      return this;

    }

    public B build() {
      return new B(this);
    }
  }

}

如何使用它：

public class Main {

  public static void main(String[] args) {
    A.Builder aBl = new A.Builder().name("I am A1");
    B.Builder bBl = new B.Builder().name("I am B1");

    A a = aBl.bB(bBl).build();

    System.out.println(a);
    System.out.println(a.b());

  }

}

^< br>
^
^
如果您想要单个类和两个循环依赖的对象）：

public class A {

  private final A other_;
  private final String name_;

  private A(Builder b) {
    if (b.otherBulder_ != null) {
      other_ = b.otherBulder_.otherInstance(this).build();
    } else {
      other_ = b.otherInstance_;
    }
    name_ = b.name_;
  }

  @Override
  public String toString() {
    return "[" + name_ + ": " + other_.name() + " ]";
  }

  public String name() {
    return name_;
  }

  public A other() {
    return other_;
  }

  static class Builder {

    private Builder otherBulder_;
    private A otherInstance_;
    private String name_;

    Builder name(String name) {
      name_ = name;
      return this;
    }

    Builder otherBuilder(Builder other) {
      otherBulder_ = other;
      return this;
    }

    Builder otherInstance(A instance) {
      otherInstance_ = instance;
      return this;
    }

    A build() {
      return new A(this);
    }
  }

  public static void main(String[] args) {
    Builder a1B = new Builder().name("A1");
    Builder a2B = new Builder().name("A2");

    A a = a1B.otherBuilder(a2B).build();
    System.out.println(a);
    System.out.println(a.other());

  }
}

Answer 2

我认为我的答案只是 Op De Cirkel 答案的简化版本，根据您的具体需求量身定制。这个想法是在构建器中拥有 gPrime 实例，因此在构造函数中，如果构建器有一个非 null gPrime，则使用它，否则构建它：

private Graph(Builder builder){


  /* .... setup code omitted....*/

  if (builder.gPrime == null){
     savedBuilder.gPrime = this;
     this.gPrime = new Graph(savedBuilder);
  }else{
     this.gPrime = builder.gPrime;
  }

}

this.gPrime.gPrime = this 将不会可以在任何地方工作，因为 gPrime 是实例的最终字段，并且只能在声明时或在该实例的构造函数中初始化。 this.gPrime.gPrime = this 所做的是初始化其他实例的 Final 字段，这违反了 gPrime 的“最终性”

Answer 3

您无法初始化不可变的循环结构。

您可以通过将 gPrime 更改为非 final 来使其有效地不可变，并确保始终在使用之前将其设置为一个值。

感谢 Op De Cirkel 的回答：

您可以使用两个构建器，或者构建器功能中的开关，其中您有一个构建器保存对当前正在构建的 Graph 对象的引用：

public class Graph {

    private final Graph gPrime;
    private final String name_;

    private Graph(PrimeBuilder b) {
        gPrime = b.g;
        name_ = b.name_;
    }

    private Graph(Builder b) {
        gPrime = new PrimeBuilder(this).name("gPrime").build();
        name_ = b.name_;
    }

    public String name() {
        return name_;
    }

    public Graph gPrime() {
        return gPrime;
    }

    @Override
    public String toString() {
        return "I am " + name_ + ", my gPrime is " + gPrime.name();
    }

    public static class PrimeBuilder {

        private Graph g;
        private String name_;

        public PrimeBuilder(Graph g) {
            this.g = g;
        }

        public PrimeBuilder name(String arg) {
            name_ = arg;
            return this;

        }

        public Graph build() {
            return new Graph(this);
        }
    }

    public static class Builder {

        private String name_;

        public Builder name(String arg) {
            name_ = arg;
            return this;
        }

        public Graph build() {
            return new Graph(this);
        }
    }

}

用法示例：

public class Main {

  public static void main(String[] args) {
    Graph g = new Graph.Builder().name("g").build();

    System.out.println(g);
    System.out.println(g.gPrime());

  }

}