# Design Pattern für zwei abhängige Klassen



## shadow (23. Feb 2011)

Hallo,

ich habe eine Anforderung, in der zwei Klassen sehr stark voneinander abhängen.
Eine direkten Verweis von jeweils der einen Klasse auf die andere möchte ich jedoch vermeiden. Ich würde gerne der einen Klasse nur ein Interface der anderen Klasse zur Verfügung stellen.

Gibt es für diesen Anwendungsfall ein Design Pattern?

Vielen Dank im Vorraus!
Stefan


----------



## Antoras (23. Feb 2011)

vermutlich Dependency Injection.


----------



## Noctarius (23. Feb 2011)

Jopp ich würde in diesem Falle auch auf DI setzen. Sauberer kann man die Abhängigkeiten nicht trennen.


----------



## Landei (23. Feb 2011)

Ich kann nur Guice empfehlen (wenn man nicht sowieso die zusätzlichen Features von Spring braucht).


----------



## fastjack (23. Feb 2011)

Ich würde da so eine Art Vermittler zwischen beiden Klassen schreiben. Vielleicht passt das Mediator-Pattern.


----------



## maki (23. Feb 2011)

> ich habe eine Anforderung, in der zwei Klassen sehr stark voneinander abhängen.


DI wird da imho nicht reichen..

Es geht wohl um eine bidirektionale Abhängigkeit, welche in eine unidirektionale umgebaut werden soll mithilfe eines Observers (-Patterns).


----------



## ARadauer (23. Feb 2011)

Wenn du kein DI einsetzen willst würd ich auf den ersten Blick Mediator sagen... zwei Objekte sollen nicht miteinander... dann muss ein Vermittler her...


----------



## shadow (23. Feb 2011)

Wow, vielen Dank für die Beiträge!

Vielleicht wäre es gut, wenn ich meinen Anwendungsfall genauer schildern würde:
Konkret geht es um ein Spiel, in dem es verschiedene Level gibt. Diese Level sind aus verschiedenen Gründen hart in die Software einprogrammiert.

Vereinfacht gibt es also eine "Game"-Klasse und mehrere Level-Klassen "Level1", "Level2", usw. und bisher ein Interface "Level". Ein Level hat beispielsweise die Kontrolle darüber, wann neue Gegner auftauchen...


```
public class Game {
   private Level currentLevel;
   private List<Enemy> enemies;

   public void newEnemy() {
     enemies.add(new Enemy());
   }

}

public interface Level {
}

public class Level1 implements Level {
}

public class Level2 implements Level {
}
```

Die Abstraktion der verschieden Levels habe ich schon über das Interface "Level".
Jetzt möchte ich auch vermeiden, dass "Level1" und "Level2" eine Referenz auf "Game" halten müssen, um die Methode "newEnemy()" aufzurufen. Instinktiv hätte ich nun nur ein Interface von "Game" in die Levels gereicht. 


```
public class Game implements PassendesPattern {
   private Level currentLevel;
   private List<Enemy> enemies;

   public void newEnemy() {
     enemies.add(new Enemy());
   }

}

public interface Level {
  public void doSomething();
}

public class Level1 implements Level {
  PassendesPattern pattern;

  public void doSomething() {
    pattern.newEnemy();
  }

}

public class Level2 implements Level {
  PassendesPattern pattern;

  public void doSomething() {
    pattern.newEnemy();
  }

}
```


Dazu suche ich jetzt ein Pattern... Ich dachte auch schon an ein Delegate, das ist allerdings unüblich gegen ein Interface ("Level"), oder?

Danke im Vorraus!


----------



## Antoras (23. Feb 2011)

Das sieht doch eher nach einem Observer-/Listener-Pattern aus. Das Pattern findest du z.B. in MVC wieder, wie hier gezeigt. MVC kannst du auch gut benutzen um die einzelnen Ebenen des Spiels zu abstrahieren, wobei du im Model wohl noch mal einen Observer einbauen kannst um zwischen den einzelnen Levels zu abstrahieren.


----------

