ClassDiagramm 0..1 до 0..1 соотносят пропущенные шаги для преобразования в код Java

Question

Я хочу написать код Java с помощью uml / диаграммы классов.Но я не уверен в этом или в том, как написать это для отношения 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

Пример в 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, не будь слишком груб со мной, если что-то глупо ^^

Answer 2

Ни один из двух классов в вашем примере ( IssueWithBankStuff или IssueWithOtherStuff ) никогда не имеет своих ссылок друг на друга set (например, в любом из них нет параметра конструкторакласс, который содержит ссылку на другой, и в конструкторах нет ничего нового, и нет мутаторов для них), что означает, что оба класса будут созданы с множественностью отношений в '0' (т. е. null ref)с самого начала и никогда не может быть «1». IssueWithBankStuff имеет переменную-член other , которая никогда не устанавливается, и IssueWithOtherStuff имеет переменную-член iban , которая также никогда не устанавливается.

Так что, на самом деле, это заботится о «0» части вашего требования.Однако для части '1' вам нужно либо где-то создать новые переменные-члены, либо для них нужны мутаторы.Например, мутатор для другой переменной-члена в IssueWithBankStuff (например, setOther (IssueWithOtherStuff other) {...} ) и мутатор для переменной-члена iban в IssueWithOtherStuff (например, setIban (IssueWithBankStuff iban) {...} ).Вызов таких мутаторов после инстанцирования дал бы вам часть «1» в кратности, в то же время позволяя начальную множественность «0» и, конечно, возвращая значение «0» множественности, передавая null в мутаторы в некоторой точке.

Если вы хотите, чтобы отношение всегда было 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.Отношения 1 к 1 следует отметить, что они - с точки зрения дизайна - обычно означают, что два типа на самом деле являются одним и тем же, или, по крайней мере, могут быть спроектированы / запрограммированы таким образом.

Я также отмечаючто у вас может быть проблема здесь с понятием смешения.У вас есть тип с именем Iban , на который ссылается IssueWithOtherStuff , затем вы также вызываете ссылку на IssueWithBankStuff 'iban'.Это довольно запутанно.

Answer 3

0..1 означает возможность.Обычно при написании кода вы должны использовать языковые конструкции с именами Null, None, Nil, Void, Optional и т. Д. Не уверен насчет Java, но я помню, что что-то в этом роде.