SOLID Prinicples

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(){..}

}