Java

Interfaces

Quelle: https://www.programmierenlernenhq.de/interfaces-in-java/

Ein Interface ist wie eine Klasse, nur dass statt “class” das Keyword “interface” benutzt wird. Ein Interface beinhaltet nur Methodendeklarationen, aber keinen Rumpf – also die Implementierung. Alles im Interface ist automatisch “public” und “abstract”, ohne, dass man es explizit dazuschreiben muss. Es darf keine Variablen und Konstruktoren haben. Das folgende Programmierbeispiel ist aus der oben angegebenen Quelle kopiert.

/*
* Beispielanwendung: das Interface Transportierbar
*/
 
public interface Transportierbar
{
  public final float MAX_GEWICHT_PRO_FLAECHE = 29.99F;
  // hier geht auch: float MAX_GEWICHT_PRO_FLAECHE = 29.99F; 
 
  // alle Methoden in Interfaces sind implizit public und abstract
  // alle vier Methodendeklarationen sind zulässig
  // jede dieser Methoden ist public und abstract
  float gewicht(); 
  abstract float laenge();
  public float breite();
  public abstract float hoehe();
 
  boolean zerbrechlich();
  String beschriftung();
}

“Alle Klassen die dieses Interface nutzen wollen, müssen es vollständig implementieren. Dazu wird an dem Namen der jeweiligen Klasse das implements-Schlüsselwort und der Name des zu implementierenden Interface angefügt.”

public class Tisch implements Transportierbar
{

Man kann nun eine Instanz von Tisch erstellen und diese Instanz einer Methode übergeben, welche Objekte vom Typ “Transportierbar” akzeptiert.  D.h. eine Klasse, die ein Interface implementiert führt zu Objekten, welche zwei Klassen angehören. Im Beispiel oben wäre Tisch tisch = new Tisch() ein Objekt der Klasse Tisch aber auch der Klasse Transportierbar.

Functional Interface

A functional interface is an interface that contains only a SINGLE  abstract (unimplemented) method. It may contain other things but not other functions.

@FunctionalInterface
public interface MyFunctionalInterface {
    public void execute(String someInput);
}

Lambda Expressions

With lambda expressions it is possible to store code in a variable. That only works if the variable is of a type defined by a functional interface can be implemented by java lambda expressions. You instantiate a variable with the type of the interface-name and set it to be equal to ()->{come code}. Since the interface has only one method (here with the name “execute”, you don’t have to specify the name for the lambda expression. The compiler can infer that. 

If you have defined a functional interface, you must define the code somewhere

public someClass implements MyFunctionalInterface{
    @Override
    public execute (String someInput){
        System.out.println("alsdkfj");
    }
}

//How to use this?
MyFunctionalInterface someName = new someClass();
resVal = someName.execute("do stuff");
System.out.println("resultVal = " + resVal);

//But this means writing a lot of code. This can be shorter with a lambda expression:
MyFunctionalInterface someName = (someInput) -> someInput + "alsdkfj";
String resVal = someName.execute("huhu");
System.out.println("resVal = " + resVal);

So what do you gain from using the lambda expression?

• No need to implement the function with override, but you can put it right there where you use it.
• The compiler automatically infers that the method ()->{} is the implementation of the method “execute”, because the variable someName is of type MyFunctionalInterface and that has only one method. 

Its probably a lot of work to create a separate functional interface every time you want to use a lambda function, so the creators of Java provide some relatively generic functional interfaces for common use cases in java.util.function

Was this helpful?

YesNo

0 / 0