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

时间:2019-01-30 21:11:19

标签: java class uml class-diagram multiplicity

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

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

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

enter image description here

我为此编写了代码。

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



}

3 个答案:

答案 0 :(得分:0)

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

答案 1 :(得分:0)

在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));
  }
}

执行总是写 true

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

答案 2 :(得分:0)

示例中的两个类( IssueWithBankStuff IssueWithOtherStuff )都没有相互引用设置(例如,没有构造函数两个类中的一个参数都引用另一个,而在构造函数中也没有任何新内容,也没有任何变数器),这意味着这两个类都将实例化为多重性为“ 0”(即从一开始就不能返回null,并且永远不能为“ 1”。 IssueWithBankStuff 的成员变量 other 从未设置,而 IssueWithOtherStuff 的成员变量 iban 也从未设置。

因此,实际上,这满足了您要求的“ 0”部分。但是,对于“ 1”部分,您要么需要在某个位置更新成员变量,要么需要一些变量。例如。 IssueWithBankStuff 中'other'成员变量的变量(例如 setOther(IssueWithOtherStuff other){...} ),以及'iban'成员变量的变量 IssueWithOtherStuff (例如 setIban(IssueWithBankStuff iban){...} )。在实例化后调用此类mutators会给您多重性的'1'部分,同时允许初始的'0'多重性,并且当然可以通过在某个点将null传递给mutators来将其设置回'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的书。在一对一关系中要注意的一件事是,它们在设计上是明智的,通常意味着两种类型实际上是相同的,或者至少可以以这种方式设计/编程。

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