<\/p>\n
Kompo…was?<\/h1>\n
Kompositum (oder auch Teile-Ganzes genannt) ist ein einfaches Muster um Hierarchien von Objekten abzubilden. Ein simples Beispiel dazu ist eine Baumstruktur wie bei einem Men\u00fc, bei dem es einen Einstiegspunkt, darunter Untermen\u00fcs und darunter ggf. wiederum weitere Untermen\u00fcs gibt. Die Besonderheit bei diesem Muster ist, dass alle Bestandteile der Hierarchie – egal ob auf der untersten Ebene (Blatt<\/strong> genannt) oder mitten im Baum (im Baum Knoten<\/strong> genannt) – gleich behandelt werden k\u00f6nnen. Alle Klassen implementieren dabei dieselbe Schnittstelle.<\/p>\n <\/p>\n Schauen wir uns einmal eine Implementierung mit Hilfe des Kompositum an und nehmen dabei allerdings nicht das bereits oben erw\u00e4hnte klassische Beispiel des Men\u00fcbaums. Machen wir es etwas interessanter … damit hat jetzt niemand gerechnet<\/em><\/strong>, oder?<\/p>\n Das nachfolgende Beispiel ist bez\u00fcglich des Kompositum vielleicht etwas ungew\u00f6hnlich. Dies soll jedoch aufzeigen, dass auch spezielle Arten von Baumstrukturen abgebildet werden k\u00f6nnen. Alles beginnt mit der einen Schnittstelle, die sp\u00e4ter von den Knoten und Bl\u00e4ttern implementiert wird.<\/p>\n In unserem Fall soll etwas berechnet und das Ergebnis vom Typ double<\/em> zur\u00fcckgegeben werden. Unser Blatt des Baums ist eine einfache Zahl. Nennen wir die Klasse Operand<\/em>, sieht der Code dazu wie folgt aus.<\/p>\n Hier wird der per Konstruktor einmalig gesetzte Wert zur\u00fcckgegeben. Soweit so einfach. Nun der Operator<\/em>.<\/p>\n Hier schauen wir einmal genauer hin, auch wenn sich die Funktionsweise vermutlich fast von selbst erkl\u00e4rt. Ein Operator besteht aus einem Operanden, aus einer Rechenvorschrift und einem weiteren Operanden. Somit k\u00f6nnten wir z.B. die Rechnung 5 + 4 abbilden. Um eine gr\u00f6\u00dftm\u00f6gliche Flexibilit\u00e4t bei der Rechenvorschrift zu haben nutzen wir hier das Strategie-Muster<\/a>.<\/p>\n Hier werden zwei Operanden miteinander verkn\u00fcpft. F\u00fcr die Addition haben wir damit folgende Implementierung.<\/p>\n F\u00fcr die Verkn\u00fcpfung der Operanden wird der jeweilige Wert \u00fcber die Methode compute()<\/em> ermittelt. Vielleicht ahnt der ein oder andere von euch an dieser Stelle schon so etwas wie Rekursion und liegt damit ganz richtig. Wir verwenden f\u00fcr die Verkn\u00fcpfung innerhalb der Rechenvorschrift nur das Interface Computable<\/em>. Demnach ist es egal, ob es sich dabei um ein Operand oder ein Operator handelt. Dies genau ist die St\u00e4rke des Kompositum: alle Bestandteile des Baum werden gleich behandelt!<\/p>\n Ein Test der Implementierung der Addition ist an dieser Stelle schon ziemlich gr\u00fcn \ud83d\ude42<\/p>\n Eine kleine Rechnung mit verschiedenen Rechenschritten l\u00e4sst sich nun in dieser Form gestalten.<\/p>\n Wir „bauen“ die Rechnung nun als Baum auf und rufen einmalig die Methode compute()<\/em> auf und erhalten das Gesamtergebnis. Wichtig dabei zu beachten ist, dass unsere Rechnung immer linksseitig ausgewertet wird! Dies liegt daran, dass in der Rechenvorschrift\u00a0 zuerst firstOperand.compute()<\/em> aufgerufen wird. Grafisch dargestellt sieht unser Baum aus obigem Beispiel so aus:<\/p>\nWie funktioniert das Kompositum?<\/h1>\n
public interface Computable {\r\n double compute();\r\n}<\/pre>\npublic class Operand implements Computable {\r\n\r\n private double value;\r\n\r\n public Operand(double value) {\r\n this.value = value;\r\n }\r\n\r\n @Override\r\n public double compute() {\r\n return this.value;\r\n }\r\n}<\/pre>\npublic class Operator implements Computable {\r\n\r\n private ComputingStrategy computingStrategy;\r\n private Computable firstOperand;\r\n private Computable secondOperand;\r\n\r\n public Operator(Computable firstOperand, ComputingStrategy computingStrategy, Computable secondOperand) {\r\n this.computingStrategy = computingStrategy;\r\n this.firstOperand = firstOperand;\r\n this.secondOperand = secondOperand;\r\n }\r\n\r\n @Override\r\n public double compute() {\r\n return this.computingStrategy.compute(firstOperand, secondOperand);\r\n }\r\n}<\/pre>\npublic interface ComputingStrategy {\r\n double compute(Computable firstOperand, Computable secondOperand);\r\n}<\/pre>\npublic class Plus implements ComputingStrategy {\r\n @Override\r\n public double compute(Computable firstOperand, Computable secondOperand) {\r\n return firstOperand.compute() + secondOperand.compute();\r\n }\r\n}<\/pre>\n@Test\r\npublic void testComputeCalcsCorrectWithoutDecimalValues() throws Exception {\r\n Operand five = new Operand(5d);\r\n Operand four = new Operand(4d);\r\n ComputingStrategy sut = new Plus();\r\n Assertions.assertThat(sut.compute(five, four)).isEqualTo(9d, Offset.offset(0.0));\r\n}<\/pre>\npublic class CompositeExample {\r\n public static void main(String...args) {\r\n Operand five = new Operand(5d);\r\n Operand four = new Operand(4d);\r\n Operand two = new Operand(2d);\r\n\r\n Operator fivePlusFour = new Operator(five, new Plus(), four);\r\n Operator twoTimesNine = new Operator(two, new Multiplication(), fivePlusFour);\r\n Operator eighteenDividedByFour = new Operator(twoTimesNine, new Division(), four);\r\n\r\n System.out.print(\"(5 + 4) * 2 \/ 4 = \");\r\n System.out.println(eighteenDividedByFour.compute());\r\n }\r\n}<\/pre>\n
![\"Composite_logo\"](\"http:\/\/invidit.de\/blog\/wp-content\/uploads\/2016\/04\/Composite_logo.png\"){kind=logo}
<\/a><\/p>\n