Hallo zusammen,
Das ist mal wieder ein etwas ketzerisches Thema, aber diese Frage geht mir schon länger nicht mehr aus dem Kopf. Gibt es irgendwelche Patterns oder Kontrukte die ich so nur mit OOP erreichen kann und die mit Komposition nicht zur Verfügung stehen? Bisher habe ich kein einziges Konstrukt gefunden was ich nur durch OOP so abbilden kann. Zugegebenermaßen bin ich nicht der größte Freund von OOP, meiner Meinung nach sind Konstrukte die per Komposition entstanden sind viel leichter zu verstehen. Aber das ist nur meine persönliche Meinung. Ihr dürft mich jetzt davon überzeugen, dass man OOP auch sinnvoll einsetzen kann
Beispiel Template Method Pattern:
[highlight=c#]
///////////////////////////////////
// Version mit abstrakter Klasse //
///////////////////////////////////
// Die abstrakte Klasse mit der Steuerungslogik
public abstract class ControllingLogic
{
public ExecuteIt()
{
if(DoStep1())
{
DoStep2();
}
else
{
DoStep3();
}
}
public abstract bool DoStep1();
public abstract void DoStep2();
public abstract void DoStep3();
}
// konkrete Implementation
public class SomeImplementation:ControllingLogic
{
public override bool DoStep1() { /* implementation */ }
public override bool DoStep2() { /* implementation */ }
public override bool DoStep3() { /* implementation */ }
}
/////////////////////////////
// Version mit Komposition //
/////////////////////////////
public interface ICanDoSteps
{
bool DoStep1();
void DoStep2();
void DoStep3();
}
public class ControllingLogic
{
private ICanDoSteps _stepExecutor;
public ControllingLogic(ICanDoSteps stepExecutor)
{
_stepExecutor = stepExecutor;
}
public ExecuteIt()
{
if(_stepExecutor.DoStep1())
{
_stepExecutor.DoStep2();
}
else
{
_stepExecutor.DoStep3();
}
}
}
public class SomeImplementation:ICanDoSteps
{
public bool DoStep1() { /* implementation */ }
public bool DoStep2() { /* implementation */ }
public bool DoStep3() { /* implementation */ }
}
[/highlight]
Ok zugegebenermaßen muss ich etwas mehr tippen und ich muss selbst dafür Sorgen dass die Klassen richtig verdrahtet werden. Dafür habe ich weniger Kopplung (Trennung durch ein Interface und nicht direkte Abhängigkeit durch Vererbung). Ähnlich sehe ich das bei vielen anderen Patterns. Dazu tendiert OOP immer noch dazu mit der Zeit Monsterklassen zu erzeugen die zu viel können und Wissen.
Hat jemand ein gutes Beispiel was für OOP spricht?
Danke
Gruß
Flo
Das ist mal wieder ein etwas ketzerisches Thema, aber diese Frage geht mir schon länger nicht mehr aus dem Kopf. Gibt es irgendwelche Patterns oder Kontrukte die ich so nur mit OOP erreichen kann und die mit Komposition nicht zur Verfügung stehen? Bisher habe ich kein einziges Konstrukt gefunden was ich nur durch OOP so abbilden kann. Zugegebenermaßen bin ich nicht der größte Freund von OOP, meiner Meinung nach sind Konstrukte die per Komposition entstanden sind viel leichter zu verstehen. Aber das ist nur meine persönliche Meinung. Ihr dürft mich jetzt davon überzeugen, dass man OOP auch sinnvoll einsetzen kann
Beispiel Template Method Pattern:
[highlight=c#]
///////////////////////////////////
// Version mit abstrakter Klasse //
///////////////////////////////////
// Die abstrakte Klasse mit der Steuerungslogik
public abstract class ControllingLogic
{
public ExecuteIt()
{
if(DoStep1())
{
DoStep2();
}
else
{
DoStep3();
}
}
public abstract bool DoStep1();
public abstract void DoStep2();
public abstract void DoStep3();
}
// konkrete Implementation
public class SomeImplementation:ControllingLogic
{
public override bool DoStep1() { /* implementation */ }
public override bool DoStep2() { /* implementation */ }
public override bool DoStep3() { /* implementation */ }
}
/////////////////////////////
// Version mit Komposition //
/////////////////////////////
public interface ICanDoSteps
{
bool DoStep1();
void DoStep2();
void DoStep3();
}
public class ControllingLogic
{
private ICanDoSteps _stepExecutor;
public ControllingLogic(ICanDoSteps stepExecutor)
{
_stepExecutor = stepExecutor;
}
public ExecuteIt()
{
if(_stepExecutor.DoStep1())
{
_stepExecutor.DoStep2();
}
else
{
_stepExecutor.DoStep3();
}
}
}
public class SomeImplementation:ICanDoSteps
{
public bool DoStep1() { /* implementation */ }
public bool DoStep2() { /* implementation */ }
public bool DoStep3() { /* implementation */ }
}
[/highlight]
Ok zugegebenermaßen muss ich etwas mehr tippen und ich muss selbst dafür Sorgen dass die Klassen richtig verdrahtet werden. Dafür habe ich weniger Kopplung (Trennung durch ein Interface und nicht direkte Abhängigkeit durch Vererbung). Ähnlich sehe ich das bei vielen anderen Patterns. Dazu tendiert OOP immer noch dazu mit der Zeit Monsterklassen zu erzeugen die zu viel können und Wissen.
Hat jemand ein gutes Beispiel was für OOP spricht?
Danke
Gruß
Flo
Comment