package com.stuelken.java.tests.a7.e40356_lambda;

/**
 * Funktionale Schnittstelle beziehungsweise funktionales Interface mit einer
 * Methode, hier für den Datentyp {@link Integer}.
 * 
 * @author t2m
 */
@FunctionalInterface
interface IRechner {
	int berechnen(int a, int b);
}

/**
 * Funktionale Schnittstelle beziehungsweise funktionales Interface mit einer
 * Methode, hier für den Datentyp {@link Double}.
 * 
 * @author t2m
 */
@FunctionalInterface
interface IRechnerDouble {
	double berechnen(double a, double b);
}

/**
 * Generisches funktionales Interface, das eine Berechnung mit zwei Werten des
 * Typs <T> durchführt und einen Wert vom gleichen Typ zurückgibt.
 * 
 * @author t2m
 * @param <T> Der Typ sowohl für die Parameter als auch den Rückgabewert.
 */
@FunctionalInterface
interface IRechnerGeneric<T> {
	T berechnen(T a, T b);
}

/**
 * Generisches funktionales Interface, das eine Berechnung mit zwei Werten des
 * Typs <T> durchführt und einen Wert vom gleichen Typ zurückgibt.
 * 
 * @author t2m
 * @param <T> Der Typ sowohl für die Parameter als auch den Rückgabewert.
 */
@FunctionalInterface
interface IRechnerGenericFlexible<T extends Number> {
	T berechnen(T a, T b);
}

/**
 * Klasse mit Beispielen die Definition von Lambda-Ausdrücken als alternative zu
 * Rechenoperatoren.
 * 
 * @author t2m
 *
 */
public class LambdaRechnerExample {

	public static void main(String[] args) {

		exampleRechnenInt();
		exampleRechnenDouble();
		exampleRechnenGenerisch();

	}

	private static void exampleRechnenInt() {

		/*
		 * Implementierungen des Interfaces mit Hilfe von Lambda-Expressions in Java
		 * welche entsprechend dem Interface jeweils zwei Parameter erwarten und einen
		 * Rückgabewert geben.
		 */

		System.out.println("Lambda-Expressions mit int-Werten:");

		IRechner additionInt = (a, b) -> a + b;
		IRechner substraktionInt = (a, b) -> a - b;
		IRechner multiplikation = (a, b) -> a * b;
		IRechner divisionInt = (a, b) -> (b != 0) ? a / b : 0; // Vermeidung von Division durch 0

		System.out.println("Ergebnis: " + additionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + substraktionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + multiplikation.berechnen(5, 3));
		System.out.println("Ergebnis: " + divisionInt.berechnen(5, 3));

	}

	private static void exampleRechnenDouble() {

		/*
		 * Da das Interface die Typen für Parameter und Return-Wert vorgibt, müssen für
		 * double-Werte ein anderes Interfaces verwendet werden.
		 */

		System.out.println("Lambda-Expressions mit double-Werten:");

		IRechnerDouble additionDouble = (a, b) -> a + b;
		IRechnerDouble substraktionDouble = (a, b) -> a - b;
		IRechnerDouble multiplikationDouble = (a, b) -> a * b;
		IRechnerDouble divisionDouble = (a, b) -> (b != 0) ? a / b : 0;

		System.out.println("Ergebnis: " + additionDouble.berechnen(5, 3));
		System.out.println("Ergebnis: " + substraktionDouble.berechnen(5, 3));
		System.out.println("Ergebnis: " + multiplikationDouble.berechnen(5, 3));
		System.out.println("Ergebnis: " + divisionDouble.berechnen(5, 3));

	}

	/**
	 * Hinweis: Java kann int nicht automatisch zu Double konvertieren, wenn ein
	 * generisches Interface genutzt wird. Es muss explizit gecastet werden.
	 */
	private static void exampleRechnenGenerisch() {

		System.out.println("Lambda-Expressions generisch mit int-Werten:");

		IRechnerGeneric<Integer> additionInt = (a, b) -> a + b;
		IRechnerGeneric<Integer> substraktionInt = (a, b) -> a - b;
		IRechnerGeneric<Integer> multiplikationInt = (a, b) -> a * b;
		IRechnerGeneric<Integer> divisionInt = (a, b) -> (b != 0) ? a / b : 0;

		System.out.println("Ergebnis: " + additionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + substraktionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + multiplikationInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + divisionInt.berechnen(5, 3));

		System.out.println("Lambda-Expressions generisch mit double-Werten:");

		IRechnerGeneric<Double> additionDouble = (a, b) -> a + b;
		IRechnerGeneric<Double> substraktionDouble = (a, b) -> a - b;
		IRechnerGeneric<Double> multiplikationDouble = (a, b) -> a * b;
		IRechnerGeneric<Double> divisionDouble = (a, b) -> (b != 0) ? a / b : 0;

		// Ohne das Casting des liefert Java eine Fehlermeldung:
		// The method berechnen(Double, Double) in the type IRechnerGeneric<Double> is
		// not applicable for the arguments (int, int)
		System.out.println("Ergebnis: " + additionDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + substraktionDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + multiplikationDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + divisionDouble.berechnen((double) 5, (double) 3));

	}

	/**
	 * Hinweis: Java kann int nicht automatisch zu Double konvertieren, wenn ein
	 * generisches Interface genutzt wird. Es muss explizit gecastet werden.
	 */
	private static void exampleRechnenGenerischFlexible() {

		System.out.println("Lambda-Expressions generisch-flexibel mit int-Werten:");

		IRechnerGenericFlexible<Integer> additionInt = (a, b) -> (int) (a.doubleValue() + b.doubleValue());
		IRechnerGenericFlexible<Integer> substraktionInt = (a, b) -> (int) (a.doubleValue() - b.doubleValue());
		IRechnerGenericFlexible<Integer> multiplikationInt = (a, b) -> (int) (a.doubleValue() * b.doubleValue());
		IRechnerGenericFlexible<Integer> divisionInt = (a,
				b) -> (int) ((b != 0) ? a.doubleValue() / b.doubleValue() : 0);

		System.out.println("Ergebnis: " + additionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + substraktionInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + multiplikationInt.berechnen(5, 3));
		System.out.println("Ergebnis: " + divisionInt.berechnen(5, 3));

		System.out.println("Lambda-Expressions generisch-flexibel mit double-Werten:");

		IRechnerGenericFlexible<Double> additionDouble = (a, b) -> a.doubleValue() + b.doubleValue();
		IRechnerGenericFlexible<Double> substraktionDouble = (a, b) -> a.doubleValue() - b.doubleValue();
		IRechnerGenericFlexible<Double> multiplikationDouble = (a, b) -> a.doubleValue() * b.doubleValue();
		IRechnerGenericFlexible<Double> divisionDouble = (a,
				b) -> (b.doubleValue() != 0) ? a.doubleValue() / b.doubleValue() : 0;

		// Ohne das Casting des liefert Java eine Fehlermeldung:
		// The method berechnen(Double, Double) in the type IRechnerGeneric<Double> is
		// not applicable for the arguments (int, int)
		System.out.println("Ergebnis: " + additionDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + substraktionDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + multiplikationDouble.berechnen((double) 5, (double) 3));
		System.out.println("Ergebnis: " + divisionDouble.berechnen((double) 5, (double) 3));

	}

}

 
INumber result = addieren.operate(a, multiplizieren.operate(b, c)); 

 

 
package com.stuelken.java.tests.a7.e40366_lambda_calculator;

/**
 * Funktionales Interface für Operationen, das zwei Operanden nimmt und ein Ergebnis liefert
 * @author t2m
 *
 * @param <T> Erster Operand der Operation, bei Rechenzeichen der Wert links vom Operator
 * @param <U> Zweiter Operand der Operation, bei Rechenzeichen der Wert rechts vom Operator
 * @param <R>
 */
@FunctionalInterface
interface IOperation<T, U, R> {
 R operate(T operand1, U operand2);
}

/**
 * Interface zur Darstellung eines skalaren Zahlenwerts.
 * 
 * Der Sinn und Zweck besteht darin, dass wir in diesem Beispiel mit Objekten
 * arbeiten und nicht mit normalen Zahlen. 
 * 
 * @author t2m
 *
 */
interface INumber {
 double getValue();
}

/**
 * Konkrete Implementierung von INumber, die einen double-Wert kapselt.
 * 
 * @author t2m
 */
class NumberObject implements INumber {
 private final double value;

 /**
 * Konstruktor für Kapselung von Zahlenwerten in einem Objekt. 
 * 
 * @param value Ein Zahlenwert welcher vom Prinzip her aber auch int, float und double
 * sein könnte, weil bei Java bei der Zuweisung normalerweise die Werte implizit
 * umwandelt.
 */
 public NumberObject(double value) {
 this.value = value;
 }

 /**
 * Methode mit deren Hilfe wir an den eigentlichen Zahlenwert
 * des Objekts gelangen können. 
 */
 @Override
 public double getValue() {
 return value;
 }
 
 /**
 * Überschreiben der von {@link Object} geerbten toString() Methode
 * weil anderenfalls statt des Strings für den Zahlenwert nur der
 * Typ NumberObject gefolgt vom Hashcode ausgegeben werden würde. 
 */
 @Override
 public String toString() {
 return Double.toString(value);
 }
}

/**
 * CustomizableCalculator, in dem wir die Operationen als Lambda-Ausdrücke definieren und nutzen
 * 
 * @author t2m
 *
 */
public class CustomizableCalculator {

 public static void main(String[] args) {
	 
 // Erzeugen der NumberObjects
 INumber a = new NumberObject(2);
 INumber b = new NumberObject(4);
 INumber c = new NumberObject(3);

 // Definition der Operationen als funktionale Interfaces
 // Addition
 IOperation<INumber, INumber, INumber> addieren =
 (x, y) -> new NumberObject(x.getValue() + y.getValue());
 
 // Multiplikation
 IOperation<INumber, INumber, INumber> multiplizieren =
 (x, y) -> new NumberObject(x.getValue() * y.getValue());

 // Berechnung: 2 + 4 * 3 (Multiplikation zuerst, weil wir sie verschachteln)
 // entspricht: addieren(a, multiplizieren(b, c))
 INumber result = addieren.operate(a, multiplizieren.operate(b, c));

 System.out.println("Ergebnis: " + result.getValue()); // Ausgabe: 14.0
 }
}

 
INumber result = addieren.operate(a, multiplizieren.operate(b, c)); 

 

 
package com.stuelken.java.b3.e03_lambda_crud;

/**
 * Beispielklasse, die alle CRUD-Operationen mithilfe von Lambda-Ausdrücken kombiniert.
 */
public class CrudLambdaExample {

	/**
	 * Hauptprogramm
	 * @param args Keine Argumente
	 */
	public static void main(String[] args) {
		
		/*
		 * === Deklaration der Funktionen
		 */
		// Erzeugungs-Operation: Erstelle ein NumberObject mit einem Startwert
		ICreate<NumberObject> creator = () -> new NumberObject(2.0);

		// Lese-Operation: Liest den aktuellen Wert, hier trivial implementiert.
		IRead<NumberObject> reader = (obj) -> obj; // Gibt das Objekt unverändert zurück

		// Update-Operation: Ändert den Wert, beispielsweise durch Addition.
		// Hier simulieren wir: update um 10 erhöhen.
		IUpdate<NumberObject> updater = (obj) -> {
			obj.setValue(obj.getValue() + 10.0);
			return obj;
		};

		// Print-Operation: Gibt den Wert des Objekts aus.
		IPrint<NumberObject> printer = (obj) -> System.out.println("Wert: " + obj.getValue());
		
		/*
		 * Eigentliche Nutzung der Funktionen
		 */

		// Ablauf: Erstellen, Lesen, Aktualisieren und Ausgeben
		NumberObject data = creator.create(); // Create
		data = reader.read(data); // Read
		data = updater.update(data); // Update
		printer.print(data); // Print
	}
}

//Funktionale Interfaces für CRUD-Operationen

@FunctionalInterface
interface ICreate<T> {
	T create();
}

@FunctionalInterface
interface IRead<T> {
	T read(T t);
}

@FunctionalInterface
interface IUpdate<T> {
	T update(T t);
}

@FunctionalInterface
interface IPrint<T> {
	void print(T t);
}

/**
 * Ein einfaches Zahlenobjekt, das einen scalar-Wert kapselt.
 * 
 * @author t2m
 */
class NumberObject {
	private double value;

	public NumberObject(double value) {
		this.value = value;
	}

	public double getValue() {
		return value;
	}

	public void setValue(double value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return Double.toString(value);
	}
}