Implementation von Beziehungen

[Urs]

Hallo, ich möchte fragen wie Beziehungen in Java implementiert werden. Ich habe bis jetzt 2 Varianten implementiert. Beide gefallen mir nicht so besonders. Beispiel: Ich habe eine Main-Klasse, eine Klasse A, B und C. Die Klasse A und C ist als Singelton implementiert. Von der Klasse B existieren 3 Objekte. Die Main und C Klasse hat auf alle Objekte von B Zugriff (Use Bezeihung). Die Klasse A muss nur auf 1 Objekt der Klasse B zugriff haben.

Meine Varianten die ich implementiert habe:
1. Die Klasse B enthält folgender Code:

    private static B b1 = null;
    private static B b2 = null;
    private static B b3 = null;

    public static B getInstanceb1() {
        if (b1 == null) {
            b1 = new B();
        }
        return b1;
    }
    public static B getInstanceb2() {
        if (b2 == null) {
            b2 = new B();
        }
        return b2;
    }
    public static B getInstanceb3() {
        if (b3 == null) {
            b3 = new B();
        }
        return b3;
    }

Der Zugriff von der C Klasse sieht dann etwa so aus:

B.getInstanceb3().macheDies();

2. Die 3 Objekte der Klasse B werden in der Main Klasse erzeugt. Beim Erzeugen der Singleton Objekte A und C gebe ich beim Konstruktor die Referenzen auf die Objekte von B mit.

Welche dieser Varianten ist Java bzw. OOP konformer? Oder ist es gar keine von meinen Varianten? Meine Erfahrung in OOP ist gering und eigentlich muss ich zugeben, dass ich das noch nicht durch und durch begriffen habe. Ich komme vom C programmieren.

Kann mir jemand weiterhelfen?

 

[byte]

Also erstmal solltest Du den static Kram entfernen. Der ergibt nämlich imo keinen Sinn. Ein Singleton hat nur eine statische Methode, nämlich um das Singleton Objekt zu bekommen. Der Rest des Singletons ist (gemäß OOP) nicht statisch. Da Du aber offensichtlich Anfänger bist, würde ich diese Patterns eh erstmal weglassen, die scheinen Dich nur zu verwirren.

Wenn Du eine einfache 1:3 Beziehung zwischen Klassen erreichen willst. Also z.B. Klasse A kennt 3 Objekte von Klasse B, dann schreibe einfach:

class A {
  private B b1, b2, b3;

  /** Konstruktor */
  public A () {
    b1 = new B(this);
    b2 = new B(this);
    b3 = new B(this);
  }
  ...
  private void doSomethingWithB() {
    b1.doSomething();
  }
}

class B {
  private A a1;

  /** Konstruktor */
  public B (A a) {
    a1 = a;
  }
  ...
  private void doSomethingWithA() {
    a1.doSomething();
  }
}

class Main {
  public static void main(String[] args) {
    A myA = new A();
  }
}

 

[Urs]

danke, und wie habe ich dann von Main Zugriff auf z.B. b1? d.h. Ich soll generell Referenzen verteilen (wie im Beispiel). Unter umständen passiert es halt, dass ich bei einem Konstruktor bis zu 5 Referenzen übergebe.
Gruss Urs

 

[byte]

Wenn Du von einer anderen Klasse auf die B Objekte von A zugreifen willst, dann schreibst Du Dir am besten geeignete Get-Methoden in der Klasse A:

class A {

  ...

  public B getB1() {
    return b1;
  }

  public B getB2() {
    return b2;
  }

  public B getB3() {
    return b3;
  }
}

Nun kannst Du von Deiner Main-Klasse, die das A-Objekt erzeugt, auf die B-Objekte zugreifen:

class Main { 
  public static void main(String[] args) { 
    A myA = new A();
    myA.getB3().doSomething(); 
  } 
}

Alternativ kannst Du, wenn Du mal sehr viele Objekte in Beziehung setzen willst, eine Liste benutzen. Wenn Du die Anzahl der Objekte kennst, kannst Du z.B. ein Array verwenden, um Deine B-Objekte zu speichern:

class A {
  //Array speichert 5 B-Objekte:
  B[] bArray = new B[4];

  public A() {
    for(int i=0; i<bArray.length; i++) {
      bArray[i] = new B();
    }
  }

  ...

  private void doSomething() {
    bArray[3].callMethodFromB();
  }
}

 

[Urs]

danke