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

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

Итак, на самом деле, это заботится о "0" части вашего требования. Однако для части '1' вам нужно либо где-то создать новые переменные-члены, либо для них нужны мутаторы. Например, мутатор для другой переменной-члена в IssueWithBankStuff (например, setOther (IssueWithOtherStuff other) {...}) и мутатор для переменной-члена iban в IssueWithOtherStuff (например, setIban (IssueWithBankStuff iban) {...}). Вызов таких мутаторов после инстанцирования дал бы вам часть "1" в кратности, в то же время позволяя начальную множественность "0" и, конечно, возвращая значение "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. Относительно отношений 1: 1 следует отметить, что они - с точки зрения дизайна - обычно означают, что два типа на самом деле одинаковы или, по крайней мере, могут быть спроектированы / запрограммированы таким образом.

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

Answer 2

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

Answer 3

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