Ja. Kurz. 40Min. Andere Sprache (C++).....
Wenn man so etwas in 3-4 Sätzen zusammenfassen könnte, ist das bestimmt um den Überblick zu erhalten besser.
Die Details kann man dann ja im Video anschauen.
Java, nich C++
Du hast zwar den case in dem aufrufenden Code vermieden, aber nun wird deine Routine, der du die Operation übergibst zu ner Monsterfunktion, die mehrere Operationen kann. Warum nicht 2 verschiedene Funktionen?
Nun mag nicht übermorgen jemand mit ner neuen Logischen Operation, die er entdeckt hat, um die Ecke kommen, aber kennt bestimmt jeder case of und 1, 2, 3 sind behandelt und huch, da hat man ja noch Fall 4 vergessen, wird hinzugefügt und muss nun überall wo man mal nen case auf diesen enum oder was gemacht hat, nachgepflegt werden. Und eh man sich versieht, hat man ne zighundert Zeilen Methode, die opBrötchenbacken, opKaffeekochen und opStaubsaugen kann. Also 3 verschiedene Methoden.
Und da kommt das Zauberwort Polymorphie ins Spiel, da kann ich mir eine Basisklasse (oder auch ein Interface) bauen, was mir meine Operation (oder auch
Strategie) abbildet.
Wie man da hin kommt, kann unterschiedlich sein. Ich persönlich find die Kombination von arrays und enums herrlich, da knallts nämlich direkt beim Kompilieren, wenn jemand mal einen neuen Wert hinzugefügt hat und nicht alle cases gefunden und angepasst hat (kennt man ja, case of ... else raise
exception.Create('unbehandelter Fall!') end
).
Ich blas das Beispiel aber nun auch gar nicht unnötigerweise mit
OOP auf sondern bleib mal bei der prozeduralen Programmierung,
da lässt sich das Prinzip nämlich auch anwenden:
Delphi-Quellcode:
type
TArrayOperation = procedure(const values: TDoubleDynArray);
TLogicalOperator = (loAnd, loOr);
procedure AndDings(const values: TDoubleDynArray);
begin
// ...
end;
procedure OrDings(const values: TDoubleDynArray);
begin
// ...
end;
const
ArrayOperations: array[TLogicalOperator] of TArrayOperation = (
AndDings,
OrDings
);
Procedure Irgendetwas;
var
MeineFunktion: TArrayOperation;
lMeinArray: TDoubleDynArray;
begin
MeineFunktion := GibMirDieOperation;
FuelleMeinArray(lMeinArray);
MeineFunktion(lMeinArray);
MeineFunktion := GibMirEineAndereOperation;
FuelleMeinArrayMitAnderenWerten(lMeinArray);
MeineFunktion(lMeinArray);
end;
In der Irgendetwas Prozedur hast du nun überhaupt nix mehr mit dem enum am Hut und sagst einfach nur, ich brauche eine Operation, gib die mir, damit ich sie aufrufen kann. Und das komplette Mapping ist in diesem Fall hardcoded und kann vom Compiler geprüft werden (in Fällen wo das dynamisch ist, würde sich ein Dictionary anbieten, wo man seine strategien registriert).
Das Beispiel mit der Polymorphie und wie man dadurch auf cases in Klassen verzichten kann, kannst du dir ja dann in Ruhe anschauen (auch wenns Java is
).