ClassDiagramm 0..1到0..1关系缺少转换为Java代码的步骤

Question

我想通过uml / class-diagram编写Java代码。 但是我不确定它或如何为关系0..1到0..1编写它

我没有找到有关此关系的任何信息。

1到0..1是可能的，我知道如何创建它。 这是我的类图，关系为0..1到0..1：

我为此编写了代码。

public class IssueWithBankStuff {

    Iban Iban;
    Bic bic;
    Customer customer;
    Date contractIban;

    IssueWithOtherStuff other;

     public IssueWithBankStuff() {

    }


     public ContractForm getContractForm() {
        return other.gethContractForm();
     }

     public void setContractForm(ContractForm contractForm) {
         other.gethContractForm(contractForm);
     }

     public isHolding() {
        return other.isHolding();
     }

     public void setHolding(Boolean hold) {
         other.setHolding(hold);
     }
     public isGeneralCorperateForm() {
        return other.isGeneralCorperateForm();
     }

     public void setHolding(Boolean generalCorperateForm) {
         other.setGeneralCorperateForm(generalCorperateForm);
     }

     public getStartDate() {
        return other.getStartDate();
     }

     public void setContractForm(Date startDate) {
         other.setStartDate(startDate);
     }

    //class specific getters and setters

}


public IssueWithOtherStuff {

    ContractForm contractForm;
    Boolean holding;
    Boolean generalCorperateForm
    Date startDate;
    IssueWithBankStuff iban;

    public IssueWithOtherStuff () {

    }


    public void setIban(Iban ib) {
        iban.setIban(ib);

    }
    public Iban getIban () {
        return iban.getIban();
    }
    public void setBic(Bic bic) {
        iban.setBic(bic);

    }
    public Bic getBic () {
        return iban.getBic();
    }
    public void setCustomer(Customer customer) {
        iban.setCustomer(customer);

    }
    public Customer getCustomer () {
        return iban.getCustomer();
    }
    public void setContractIban(Date contractIban) {
        iban.setContractIban(contractIban);

    }
    public Date getContractIban () {
        return iban.getContractIban();
    }

    //getters and setters



}

Answer 1

0..1表示可选项。 通常，在编写代码时，您将使用名为Null，None，Nil，Void，Optional等的特定于语言的构造。不确定Java，但我记得有一些类似的东西。

Answer 2

Java中用于管理A -0..1----0..1- B的示例，当在两侧的任一侧完成设置时，在另一侧也进行了设置：

A.java

public class A {
  private B b;

  public void setB(B v) {
    if (b != v) { 
      B prev = b;

      b = v; // set relation here

      if (prev != null) {
        // remove relation on other side
        prev.setA(null);

        // if prev->a was this now b is null, set it again
        b = v;
      }

      if (b != null)
        // add relation on other side
        b.setA(this);
    }
  }

  public B getB() { return b; }
}

B.java

public class B {
  private A a;

  public void setA(A v) {
    if (a != v) { 
      A prev = a;

      a = v; // set relation here

      if (prev != null) {
        // remove relation on other side
        prev.setB(null);

        // if prev->b was this now a is null, set it again
        a = v;
      }

      if (a != null)
        // add relation on other side
        a.setB(this);
    }
  }

  public A getA() { return a; }
}

并检查Main.java：

class Main {
  public static void main(String[] args) {
    A a = new A();
    B b = new B();

    a.setB(b);
    System.out.println((a.getB() == b) && (b.getA() == a));

    a.setB(null);        
    System.out.println((a.getB() == null) && (b.getA() == null));

    b.setA(a);
    System.out.println((a.getB() == b) && (b.getA() == a));

    b.setA(null);        
    System.out.println((a.getB() == null) && (b.getA() == null));

    B bb = new B();

    a.setB(b);
    a.setB(bb);
    System.out.println(b.getA() == null);
    System.out.println((a.getB() == bb) && (bb.getA() == a));
  }
}

执行一直写为真

请因为我不是Java程序员，如果有些愚蠢的话不要对我太粗鲁^^

Answer 3

无论您的样品（IssueWithBankStuff或IssueWithOtherStuff）在两班曾经有它们的引用彼此集 （例如有在任一类携带到其他的引用没有构造函数的参数，也没有任何的构造函数new'ing起来，也没有任何变数器），因此这两个类从一开始就将实例的关系多重性实例化为“ 0”（即空引用），并且永远不会为“ 1”。 IssueWithBankStuff的成员变量other从未设置，而IssueWithOtherStuff的成员变量iban也从未设置。

因此，实际上，这可以满足您要求的“ 0”部分。 但是，对于“ 1”部分，您要么需要在某个位置更新成员变量，要么需要一些变量。 例如，用于在IssueWithBankStuff的“其他”成员变量增变（例如setOther（IssueWithOtherStuff其他）{...}）和突变在IssueWithOtherStuff的“IBAN”成员变量（例如setIban（IssueWithBankStuff IBAN）{...} ）。 在实例化后调用此类mutators将为您提供多重性的'1'部分，同时允许初始的'0'多重性，并且当然可以通过在某个点将null传递给mutator来重新设置为'0'多重性。

如果您希望始终保持1到1的关系（而不是0..1到0..1），则由于实例化中的循环引用，在Java中实现此关系的选项有限。 最简单的方法是在另一个的构造函数中新建一个，如下所示：

public class A
{
    private B theRefToB;

    public A ()
    {
        theRefToB = new B (this);
    }
}

public class B
{
    private A theRefToA;

    public B (A a)
    {
        theRefToA = a;
    }
}

当然，这确实需要谨慎使用，并且需要很多内联注释，因为您可以轻松地直接创建一个B，传入一个新的A（），最后得到两个B。 您直接构造的B将是一个孤儿，没有连接的A，而第二个B将在A的构造函数中创建。您可能能够使用一些巧妙的作用域来减轻这种风险，在C＃中，您可能会使用内部范围可能会有所帮助。 我必须挖掘一下有关Java的书。 在一对一关系中要注意的一件事是，它们是明智的设计，通常意味着两种类型实际上是相同的，或者至少可以以这种方式设计/编程。

我还注意到，您可能在这里遇到概念合并问题。 您在IssueWithOtherStuff中引用了一个名为Iban的类型，然后也将对 IssueWithBankStuff的引用也称为“ iban”。 这很令人困惑。