Vorwort

Lambda-Ausdruck, eine neue Funktion von Java8. Mithilfe des Lambda-Ausdrucks können Sie die Schnittstellenimplementierung durch nur eine Funktion ersetzen, sich von anonymen inneren Klassen verabschieden und der Code sieht prägnanter und leichter verständlich aus.
Java8 hat auch einige andere neue Funktionen, die jedoch möglicherweise nicht auf Android verfügbar sind.
Studio 2.x und höher unterstützt den Jack-Compiler. Mit ihm können Sie den Lambda-Ausdruck von Java8 verwenden, es gibt jedoch keine Garantie, dass andere Funktionen verfügbar sind.

Hinweis: Das Android SDK integriert einen Teil des Quellcodes des JDK. Einigen Klassen im nativen JDK sind möglicherweise einige Implementierungen neuer Funktionen hinzugefügt, bei denen in Android jedoch nicht. Ein weiteres Beispiel ist das java.util.function-Paket von java8, das in niedrigeren Versionen nicht verfügbar ist

Sie können auch das Plug-in retrolambda verwenden, um den Lambda-Ausdruck von java8 zu unterstützen.

Jack-Konfiguration

Fügen Sie die folgende Konfiguration hinzu

android {
    jackOptions {
        enabled true
    }
    compileOptions {//jack、retrolambda编译必需        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

, damit der Jack-Compiler den Lambda-Ausdruck unterstützen kann

Verwenden Sie die neueste Version 2.3 Studio, JDK 1.8-Umgebung, Gradle2.3 und die obige Konfiguration
Nach dem Testen kann es auch auf dem 4.4-Simulator
ausgeführt werden Konfigurationsdemo: //m.sbmmt.com/

retrolambda-Konfiguration

retrolambda ist mit Java5, 6 und 7 unter Verwendung des Lambda-Ausdrucks kompatibel.

Die Konfiguration ist wie folgt

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.3'
        classpath 'me.tatarka:gradle-retrolambda:3.6.0'
    }}
apply plugin: 'me.tatarka.retrolambda'android {
    defaultConfig {
        minSdkVersion 11 //这个没有硬性要求
    }
    compileOptions {//jack、retrolambda编译必需
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }}

Hinweis: Viele Open-Source-Projekte verwenden immer noch Retrolambda

So verwenden Sie den Lambda-Ausdruck

Zunächst müssen wir wissen, dass dieser Ausdruck als Ganzes einen „Objekttyp“ ausdrückt.

Der einfachste Lambda-Ausdruck

Code:

Runnable runnable = () -> System.out.println("hi, 我是 stone");runnable.run();

() ist eigentlich die Methodenparameterliste. Wenn hier keine Parameter übergeben werden, entspricht sie der Methode ohne Parameter . Da Runnable nur einen void run() hat, wird der Methodenname hier nicht geschrieben, sodass der Methodenname ignoriert wird.

-> Darauf folgt der Methodenkörper. Hier gibt es nur einen Druckcode. Sie können die geschweiften Klammern des Methodenkörpers weglassen: {}.

Hinweis: Code wie „new Runnable“ wird hier ebenfalls weggelassen, da der Compiler eine automatische Typinferenz durchführt. Wenn Sie () direkt aufrufen -> >

button.setOnTouchListener((view, event)-> {    
if (event.getAction() == MotionEvent.ACTION_DOWN) {        
if (flag) {            
return true;
        }
    }    return super.onTouchEvent(event);
});

Wenn ein Rückgabewert vorhanden ist, können Sie return im Methodenkörper verwenden. Sie können return auch weglassen, wenn nur ein Teil des Codes vorhanden ist, wie folgt:

button.setOnTouchListener((v, e) -> super.onTouchEvent(e));

    interface IGetData<T> {//lambda只能用于单一方法类型匹配
        T get();//      T getOne(int i); //多个抽象方法，直接编译不过
    }

    void print(IGetData<String> data) {        
    String msg = data.get();        
    System.out.println(msg);
    }

        print(() -> "张三");        print(() -> {
            System.out.println("干活了");            return "李四";
        });

03-08 06:46:00.430 1510-1510/? I/System.out: 张三
03-08 06:46:00.430 1510-1510/? I/System.out: 干活了
03-08 06:46:00.430 1510-1510/? I/System.out: 李四

• Eine Befehlsschnittstelle definiert eine abstrakte Methode zur einheitlichen Ausführung von Befehlen

• Jeder spezifische Commander implementiert die Befehlsschnittstelle und verlässt sich auf einen Empfänger Objekt, Befehl Der Ausführungsagent wird dem Empfänger übergeben, um die Aufruferklasse

• auszuführen, die auf einem Befehlsschnittstellenobjekt basiert und von der Befehlsschnittstelle ausgeführt wird. Übergeben Sie verschiedene spezifische Befehle polymorph, und letztendlich übernimmt der Empfänger unterschiedliche Ausführungsmethoden

Nun, zunächst müssen Sie eine Befehlsschnittstelle definieren: IAction

public interface IAction {//原 命令者  抽象出一个 执行命令的方法
    void perform();
}

CloseAction-Code:

public class CloseAction implements IAction {
    private Editor mEditor;    
    public CloseAction(Editor editor) {        
    this.mEditor = editor;
    }    
    @Override
    public void perform() {        
    this.mEditor.close();
    }
}

public class Editor {     public void save() {
          System.out.println("save");
      }      public void delete() {
          System.out.println("delete");
      }      public void open() {
          System.out.println("open");
      }      public void close() {
          System.out.println("close");
      }
}

Hinweis: Wenn verschiedene Editoren unterschiedliche Anforderungen an diese Befehle haben, wenn es unterschiedliche Implementierungen gibt, Sie können auch eine IEditor-Schnittstelle definieren und dann verschiedene Editoren implementieren. Auf diesen Punkt wird nicht näher eingegangen

public class Invoker {  
    private IAction action;  

    public Invoker(IAction action) {  
        this.action = action;  
    }  

    public void invoke() {  
        this.action.perform();  
    }  
}

Editor editor = new Editor();
new Invoker(new OpenAction(editor)).invoke();
new Invoker(new CloseAction(editor)).invoke();
new Invoker(new SaveAction(editor)).invoke();
new Invoker(new DeleteAction(editor)).invoke();

private void invoke(IAction action) {
    action.perform();
}

 invoke(new OpenAction(editor)); 
 invoke(new CloseAction(editor)); 
 invoke(new SaveAction(editor)); 
 invoke(new DeleteAction(editor));

  Editor editor = new Editor();
  invoke(() -> editor.open());  
  invoke(() -> editor.close());  
  invoke(() -> editor.save());  
  invoke(() -> editor.delete());

Denn invoke(() -> editor.open()); <==>

invoke(new IAction() {    @Override
    public void perform() {
        editor.open();
    }
});

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in den Beispielcode von Lambda Expression, einer neuen Funktion von Android mit Java 8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!