OOP Frage zu Klassendesign

[SC]

Folgendes Szenario:
Ich habe eine Superklasse "Connection", die im Kostruktor die Parameter "User" und "Passwort" erwartet und dann eine Connection aufbaut, die in einem Klassenattribut gespeichert wird.
Die Superklasse hat die Methoden create, update und delete, die alle einen Parameter "Type" erwarten.
Die beiden Subklassen "TypeX"und "TypeY" bieten ebenfalls die Methoden create, update und delete an. Diese sollen allerdings nicht direkt aufgerufen werden können, sondern nur von der Superklasse benutzt werden.
Wenn die Methode der Superklasse nun mit dem Wert X aufgerufen wird, soll die create, update und delete Methode der TypeX-Klasse aufgerufen werden.
Kann man das so machen? Ich habe mal gelesen, dass die Superklassen eigentlich kein Wissen über seine Subklassen haben soll. Wie könnte man das denn sonst machen?

 

[Andi_CH]

Völlig falscher Ansatz!

Wie du richtig bemerkt hast, weiss die Superklasse rein gar nichts von Subklassen und kann dort auch nichts aufrufen.

Ich vermute es ist andersrum gemeint - die Methoden in der Superklasse darf nicht direkt aufgerufen werden und die Subklassen sollen auf die Methode der Superklasse zugreifen.

Gelöst kann das imho nur werden wenn man eine weitere unabhägnige Klasse vorschaltet, die die Fallunterscheidung macht.

 

[Andi_CH]

Hm, andere Idee - in den Objekten der Klassen X und Y die Methoden mit dem Parameter überschreiben, darin überprüfen ob der Parameter stimmt und dann, wenn ok den entsprechenden Code ausführen (evtl mit super.<methode> ....

Dann zur Laufzeit einfach die Methode auf allen vorhandenen Objekten aufrufen ....

 

[bygones]

naja völlig ist hier n bisschen extrem...

wenn die beiden Subklassen package private sind und nur die Oberklasse public ist, so können die Verwender nur mit der Superklasse arbeiten.

bsp

// package foo
public abstract Foo {
  public static Foo getSubType() {
      return new SubFoo();
  }
  
  public abstract void add();
}

class SubFoo extends Foo {
   public void add() {
      System.out.println("hallo");
}

// package other
public class Test {
   public static void main(String[] args) {
      Foo.getSubType().add(); // prints hallo
  }
}

unschön ist es aber, da nun die Oberklasse für die Instanzierung der Unterklassen zuständig ist... Kann man auch gern in eine Factory trennen.

 

[Andi_CH]

Hm - unschön (gelinde gesagt ;-) ) ist aber die gegenseitig Abhängigkeit die jetzt vorhanden ist.

Subklasse kennt Superklasse (-> Logisch muss ja)
Aber "Superklasse kennt Subklasse" (-> ich glaube das würde nicht sehr lange dauern bis mein Chef da steht und eine Frage stellt ;-) )

Darum habe ich von "unabhängiger Klasse" gesprochen (so eine Art Router oder Dispatcher)
Oder eben man gibt jedem Objekt die Fähigkeit zu entscheiden ob es etwas zu tun hat oder nicht

 

[bygones]

hab ich auch geschrieben...
damit du zufrieden bist

// package foo
public abstract Foo { 
  public abstract void add();
}
 
class SubFoo extends Foo {
   public void add() {
      System.out.println("hallo");
}

public class FooFactory {
   public static Foo getFooType() {
      return new SubFoo();
   }
}
 
// package other
public class Test {
   public static void main(String[] args) {
      FooFactory.getSubType().add(); // prints hallo
  }
}

 

[SC]

Vielen Dank. Ich werde mir das Factory-Pattern mal genauer ansehen