# Eigenes funktionales Interface schreiben



## n01sp (23. Mai 2016)

Guten Tag,
ich bins mal wieder mit einem neuen Problem. Wir haben die Aufgabe bekommen die unten steht, ist allerdings nur ein Teil der kompletten, aber leider der Grundstein für die komplette Aufgabe.
Ich habe auch schon gegoogelt, aber nicht gefunden wie man ein eigenes funktionales Iinterface schreibt.
Ich kam nur auf die Idee ein Interface zu schreiben mit der Methode drin, nun ist die Frage was würde mir ein Interface bringen was nur die Methode zur Verfügung stellt?



Aufgabe:
Sie möchten zwei Strings miteinander vergleichen und eine Entscheidung
erhalten, welcher der beiden verwendet werden soll. Um einen Lambda-Ausdruck dafür nutzen
zu können benötigen Sie ein passendes funktionales Interface. Schreiben Sie ein funktionales
Interface, das zwei Strings als Parameter verlangt und einen boolschen Wert zurückgibt.


----------



## mrBrown (23. Mai 2016)

Ein "funktionales Interface" ist einfach nur ein Interface mit genau einer Methode und der 
@FunctionalInterface-Annotation.
Der Vorteil davon ist, dass man sie nicht implementieren muss, sondern als Lambda-Expression schreiben kann.

Du kannst auch mal ins java.util.function-Package gucken, da gibts das was du brauchst schon fast fertig...


----------



## n01sp (23. Mai 2016)

Alles klar.


----------



## n01sp (23. Mai 2016)

```
package ha5;

import java.util.function.BiFunction;

public class test {

    public String betterString(String str1,String str2,StringComp bi){
        boolean tr =bi.compare(str1, str2);
        if(tr = true)
            return str1;
        if(tr = false)
            return str2;
        else
            return null;
       
       
    }
    public static void main(String[] args) {
        StringComp bi = (String str,String str1) ->  bi.compare("Hallo", "Tschüß");
        System.out.println(bi);
   
    }
}
```


```
package ha5;
@FunctionalInterface
public interface StringComp {
    boolean compare(String o1, String o2);
}
```

Soweit ist alles gut, aber wie erschaffe ich jetzt z.B. einen Lamda- Ausdruck der immer den zweiten String zurückgibt?


----------



## mrBrown (23. Mai 2016)

Die Aufgabe ist damit imho schon gelöst. Deine `test`-Klasse enthält aber noch einige Fehler...


Zwei Strings erhalten und einen zurückgeben wäre eine BiFunction, die dein StringComp nutzt. zB:

```
StringComp bi = (String s1, String s2) -> true//je nachdem wie ausgewählt werden soll...
BiFunction<String,String,String> stringSelector = (String s1, String s2) -> bi.compare(s1, s2) ? s1 :s2;
```


----------



## n01sp (23. Mai 2016)

Wenn ich StringComp instanzieren will gibt er mir die Fehlermeldung, dass man den Typen nicht instanzieren kann.


----------



## mrBrown (23. Mai 2016)

Sorry, dein StringComp musst du natürlich als LampdaExpression schreiben (oder implementieren).
Und zwar, ohne es selbst darin zu benutzen


----------



## Flown (23. Mai 2016)

Wie lautet denn bitte deine ganze Aufgabe?


----------



## n01sp (23. Mai 2016)

Sie möchten zwei Strings miteinander vergleichen und eine Entscheidung
erhalten, welcher der beiden verwendet werden soll. Um einen Lambda-Ausdruck dafür nutzen
zu können benötigen Sie ein passendes funktionales Interface. Schreiben Sie ein funktionales
Interface, das zwei Strings als Parameter verlangt und einen boolschen Wert zurückgibt.


Implementieren Sie eine Methode betterString(...), die zwei Strings und
einen Lambda-Ausdruck von der oben genannten Form erhält. Die Methode soll nun bei true
den ersten und bei false den zweiten String zurückgeben.


Rufen Sie Ihre Methode auf und geben Sie Lambda-Ausdrücke für die
folgenden Fälle an:
Es wird immer der erste String zurückgegeben.
Es wird der längere String zurückgegeben.
Es wird der String mit den meisten Großbuchstaben zurückgegeben (bei Gleichheit der
erste).

Generische Typen Schreiben Sie ein zweites Interface, das mithilfe von generischen Datentypen
offen lässt, ob Strings verwendet werden. Allerdings soll weiterhin zweimal der gleich
Datentyp verwendet werden. Überprüfen Sie, ob die oben geschilderten Fälle weiterhin funktionieren.
Ergänzen Sie die weiteren Fälle:
Es wird der größere Integer zurückgegeben.
Es wird das kürzere Array zurückgegeben.


----------



## mrBrown (23. Mai 2016)

Die betterString-Methode und das Interface hast du schon, du musst #betterString nur noch jeweils den passenden Lambda-Ausdruck für die drei Fälle übergeben 
Die Lösung für einen davon steht weiter oben sogar schon...

Wenn du Generics kannst, sollte das generische Interface kein Problem sein, ich gehe mal davon aus, das ihr Generics schon hattet?


----------



## Flown (23. Mai 2016)

Besser wäre:
	
	
	
	





```
public static String betterString(String str1, String str2, StringChooser sc) {
  boolean tr = sc.isFirst(str1, str2);
  if (tr) {
    return str1;
  } else {
    return str2;
  }
}
```
Oder gar:

```
public static String betterString(String str1, String str2, StringChooser sc) {
  return sc.isFirst(t1, t2) ? t1 : t2;
}
```


----------



## n01sp (24. Mai 2016)

```
package ha5;

import java.util.function.BiFunction;

public class test {

    public static String betterString(String str1,String str2,StringComp bi){
    return    bi.compare(str1, str2) ? str1:str2;
       
       
    }
    public static void main(String[] args) {
        StringComp bi = (s1,s2) -> true;
        StringComp be = (s1,s2) -> s1.length()>= s2.length();
        StringComp ba = (s1,s2) -> s1.chars().filter(Character::isUpperCase).count() >=    s2.chars().filter(Character::isUpperCase).count();   
        System.out.println(betterString("hallo", "bye",bi));
        System.out.println(betterString("hallo", "byeeeee",be));
        System.out.println(betterString("hallo", "Bye",ba));
   
    }
}
```

Ist jetzt so kurz wie möglich.


----------



## Flown (24. Mai 2016)

Nimm beim StringComp ba lieber: codePoints () statt chars ()


----------

