S Single Responsibility: Klassen darf nur eine zuständigkeit haben
O Open Closed Principle: Offen gegnüber Erweiterung closed für Änderungen
Sollte ohne änderungen an Klasse erweiterbar sein.
Falscher Weg
Public class StringTransformer
{
String anyString;
….
Public String Transform()
{
Return anyString.toUpperCase();
}
Static void main(string[] args)
{
Transformer = new StringTransformer("Foo");
Println(transformer.transform());
}
}
Richtiger weg
Public class StringTransformer
{
String anyString;
….
Public String Transform( ITransaformStrategy strategy)
{
Return strategy.Transform(anyString);
}
Static void main(string[] args)
{
Transformer = new StringTransformer("Foo");
Println(transformer.transform(new ToUpperTransformator()));
}
Interface ITransformStrategy
{
String Transform(string mystring);
}
Class ToLowerTransformator
{
String Transform(string mystring)
{
Return mystring.toLowerCase();
}
}
Class ToUpperTransformator
{
String Transform(string mystring)
{
Return mystring.toUpperCase();
}
}
}
L Liskovische Sustitution Prinizipen :
Public class Rectangle() {
Breite;
Länge;
….
}
Public class Square implements Rectangle
{
Public int GetFläche(){
Breite*2;
}
}
Static void main(string[] args) {
Rect = new Rectangle(20,20);
Quad = new Square(20);
Println(quad.getFlache());
Rectangle rect2 = quad;
Rect2.Länge = 50; // verletzt Liskovische Subsitution Prinizipien da andere attributes von basis klasse rein kommen die nicht da gehorn
}
Basis klasse nicht durch sub klasse ersetzen kann.
I Interface Segregation:
Fein granulation von Interfaces soll helfen verhalten einfach auszutauschen.
Falscher Weg
Public class Transformer implements ITransformator
{
Public String transformString(String mystring)
{
Return mystring.toUpperCase();
}
Public String transformDateTime(DateTime myDateTime)
{
Return myDateTime.toString();
}
Static void main(string[] args)
{
ITransformer transformer = new Transformer("Foo");
Println(transformer.transformString());
}
Interface ITransformator
{
String TransformString(string mystring) {..};
DateTime TransformDateTime(DateTime mydate) {..};
}
Class IOtherTransformator Implements ITransformator
{
String TransformString(string mystring){..};
DateTime TransformDateTime(DateTime mydate){..};
}
}
Problem: wenn ein andere Class Interface implementieren will, muss die alle Methoden uberschreiben auch wenn die gar nicht nötig sind.
Richtiger weg
Public class Transformer implements IStringTransformator, IDateTimeTransformator
{
….
Public String TransformString(String mystring)
{
Return mystring.toUpperCase();
}
Public String TransformDateTime(DateTime myDateTime)
{
Return myDateTime.toString();
}
Static void main(string[] args)
{
Transformer = new StringTransformer("Foo");
Println(transformer.transform());
}
Interface IStringTransformator
{
String TransformString(string mystring);
}
Interface IDateTimeTransformator
{
DateTime TransformDateTime(DateTime mydate);
}
Class IOtherTransformator implements IStringTransformator
{
String TransformString(string mystring){..};
}
}
Nur das ändern was man will.
D Dependency Inversion: drehe Zuständigkeit abhängigkeit um.
Falscher weg
Public class A
{
Public A(B b)
{..}
Public String DoA()
{
String dat = b.DoB();
dat = dat.ToLowercase();
Return dat;
}
}
Public class B
{
public String DoB(){..}
}