文章目錄

• • 1. Lambda表達式
  • • 1.1 Lambda表達式初體驗
    • 1.2 Lambda表達式的基本格式
    • 1.3 Lambda表達式練習
    • 1.4 Lambda表達式的省略規則
    • 1.5 Lambda表達式的注意事項
    • 1.6 Lambda表達式和匿名內部類的區別
  • 2. 接口組成更新
  • • 2.1 接口組成更新概述
    • 2.2 接口中默認方法應用
    • 2.3 接口中靜態方法應用
    • 2.4 接口中私有方法應用
  • 3. 方法引用
  • • 3.1 方法引用初體驗
    • 3.2 方法引用符
    • 3.3 方法引用類對象練習
    • 3.4 方法引用對象的實例方法
    • 3.5 方法引用類的實例方法
    • 3.6 引用構造方法

1. Lambda表達式

1.1 Lambda表達式初體驗

案例需求
啟動一個線程，在控制臺輸出一句話：多線程程序啟動了

實現方式一
實現步驟
定義一個類MyRunnable實現Runnable接口，重寫run()方法
創建MyRunnable類的對象
創建Thread類的對象，把MyRunnable的對象作為構造參數傳遞
啟動線程

實現方式二
匿名內部類的方式改進

實現方式三
Lambda表達式的方式改進

public class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("多線程程序啟動了");} } public class LambdaDemo {public static void main(String[] args) {//實現類的方式實現需求 // MyRunnable my = new MyRunnable(); // Thread t = new Thread(my); // t.start();//匿名內部類的方式改進 // new Thread(new Runnable() { // @Override // public void run() { // System.out.println("多線程程序啟動了"); // } // }).start();//Lambda表達式的方式改進new Thread( () -> {System.out.println("多線程程序啟動了");} ).start();} }

函數式編程思想概述

函數式思想則盡量忽略面向對象的復雜語法：“強調做什么，而不是以什么形式去做”而我們要學習的Lambda表達式就是函數式思想的體現

1.2 Lambda表達式的基本格式

1.3 Lambda表達式練習

練習一：

定義一個接口(Eatable)，里面定義一個抽象方法：void eat();
定義一個測試類(EatableDemo)，在測試類中提供兩個方法 一個方法是：useEatable(Eatable e)
一個方法是主方法，在主方法中調用useEatable方法

public interface Eatable {void eat(); } public class EatableImpl implements Eatable {@Overridepublic void eat() {System.out.println("一天一蘋果，醫生遠離我");} } public class EatableDemo {public static void main(String[] args) {//在主方法中調用useEatable方法Eatable e = new EatableImpl();useEatable(e);//匿名內部類useEatable(new Eatable() {@Overridepublic void eat() {System.out.println("一天一蘋果，醫生遠離我");}});//Lambda表達式useEatable(() -> {System.out.println("一天一蘋果，醫生遠離我");});}private static void useEatable(Eatable e) {e.eat();} }

練習二：有參有返回值抽象方法的練習
定義一個接口(Addable)，里面定義一個抽象方法：int add(int x,int y);
定義一個測試類(AddableDemo)，在測試類中提供兩個方法 一個方法是：useAddable(Addable a)
一個方法是主方法，在主方法中調用useAddable方法

public interface Addable {int add(int x,int y); }public class AddableDemo {public static void main(String[] args) {//在主方法中調用useAddable方法useAddable((int x,int y) -> {return x + y; // return x - y;});}private static void useAddable(Addable a) {int sum = a.add(10, 20);System.out.println(sum);} }

其實，lambda表達式的代碼塊就是抽象方法的實現 形式。

1.4 Lambda表達式的省略規則

代碼演示

public interface Addable {int add(int x, int y); }public interface Flyable {void fly(String s); } public class LambdaDemo {public static void main(String[] args) { // useAddable((int x,int y) -> { // return x + y; // });//參數的類型可以省略useAddable((x, y) -> {return x + y;});//但是有多個參數的情況下，不能只省略一個 // useAddable((x,int y) -> { // return x + y; // });// useFlyable((String s) -> { // System.out.println(s); // }); // useFlyable((s) -> { // System.out.println(s); // });//如果參數有且僅有一個，那么小括號可以省略 // useFlyable(s -> { // System.out.println(s); // });//如果代碼塊的語句只有一條，可以省略大括號和分號useFlyable(s -> System.out.println(s));//如果代碼塊的語句只有一條，可以省略大括號和分號，如果有return，return也要省略掉useAddable((x, y) -> x + y);}private static void useFlyable(Flyable f) {f.fly("風和日麗，晴空萬里");}private static void useAddable(Addable a) {int sum = a.add(10, 20);System.out.println(sum);} }

1.5 Lambda表達式的注意事項

1.6 Lambda表達式和匿名內部類的區別

2. 接口組成更新

2.1 接口組成更新概述

常量 public static final抽象方法 public abstract默認方法(Java 8) public default 返回值類型 方法名(參數列表) { }靜態方法(Java 8) public static 返回值類型 方法名(參數列表) { }私有方法(Java 9) private 返回值類型 方法名(參數列表) { }

2.2 接口中默認方法應用

public interface MyInterface {void show1();void show2(); }public class MyInterfaceImplOne implements MyInterface {@Overridepublic void show1() {System.out.println("One show1");}@Overridepublic void show2() {System.out.println("One show2");} }public class MyInterfaceDemo {public static void main(String[] args) {//按照多態的方式創建對象并使用MyInterface my = new MyInterfaceImplOne();my.show1();my.show2();} }

如果我們在接口中新增抽象方法，就必須在實現類中重寫抽象方法，否則編譯無法通過，有沒有什么辦法解決呢？

在JDK8中，引入了默認方法，如果抽線方法被設置為默認方法，就不需要在實現類中進行實現。但是，也可以在實現類中重寫抽象方法。

public interface MyInterface {void show1();void show2();// void show3();// public default void show3() { // System.out.println("show3"); // }default void show3() {System.out.println("show3");} }public class MyInterfaceDemo {public static void main(String[] args) {//按照多態的方式創建對象并使用MyInterface my = new MyInterfaceImplOne();my.show1();my.show2();my.show3();} }

2.3 接口中靜態方法應用

public interface Inter {void show();default void method(){System.out.println("Inter 中的默認方法執行了");}// public static void test(){ // System.out.println("Inter 中的靜態方法執行了"); // }static void test(){System.out.println("Inter 中的靜態方法執行了");} }public interface Flyable {public static void test() {System.out.println("Flyable 中的靜態方法執行了");} }public class InterImpl implements Inter,Flyable {@Overridepublic void show() {System.out.println("show方法執行了");} }public class InterDemo {public static void main(String[] args) {//按照多態的方式創建對象并使用Inter i = new InterImpl();i.show();i.method(); // i.test();Inter.test(); // InterImpl.test();Flyable.test();} }

2.4 接口中私有方法應用

私有方法產生原因

Java 9中新增了帶方法體的私有方法，這其實在Java 8中就埋下了伏筆：Java 8允許在接口中定義帶方法體的默認方法和靜態方法。這樣可能就會引發一個問題：當兩個默認方法或者靜態方法中包含一段相同的代碼實
現時，程序必然考慮將這段實現代碼抽取成一個共性方法，而這個共性方法是不需要讓別人使用的，因此用私有給隱藏起來，這就是Java 9增加私有方法的必然性。

public interface Inter {default void show1() {System.out.println("show1開始執行"); // System.out.println("初級工程師"); // System.out.println("中級工程師"); // System.out.println("高級工程師"); // show();method();//默認方法可以調用私有的靜態方法和非靜態方法System.out.println("show1結束執行");}default void show2() {System.out.println("show2開始執行"); // System.out.println("初級工程師"); // System.out.println("中級工程師"); // System.out.println("高級工程師"); // show();method();System.out.println("show2結束執行");}private void show() {System.out.println("初級工程師");System.out.println("中級工程師");System.out.println("高級工程師");}static void method1() {System.out.println("method1開始執行"); // System.out.println("初級工程師"); // System.out.println("中級工程師"); // System.out.println("高級工程師"); // show();method();//靜態方法只能調用靜態方法，而不能調用非靜態方法System.out.println("method1結束執行");}static void method2() {System.out.println("method2開始執行"); // System.out.println("初級工程師"); // System.out.println("中級工程師"); // System.out.println("高級工程師");method();System.out.println("method2結束執行");}private static void method() {System.out.println("初級工程師");System.out.println("中級工程師");System.out.println("高級工程師");} }public class InterImpl implements Inter { }public class InterDemo {public static void main(String[] args) {//按照多態的方式創建對象并使用Inter i = new InterImpl();i.show1();System.out.println("--------");i.show2();System.out.println("--------");Inter.method1();System.out.println("--------");Inter.method2();} }

3. 方法引用

3.1 方法引用初體驗

方法引用的出現原因

在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿參數做操作

那么考慮一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯呢？答案肯定是沒有必要

那我們又是如何使用已經存在的方案的呢？
這就是我們要講解的方法引用，我們是通過方法引用來使用已經存在的方案

public interface Printable {void printString(String s); }public class PrintableDemo {public static void main(String[] args) {//在主方法中調用usePrintable方法// usePrintable((String s) -> { // System.out.println(s); // });usePrintable(s -> System.out.println(s));// System.out.println("愛生活愛Java");//方法引用符：::usePrintable(System.out::println);//可推導的就是可省略的}private static void usePrintable(Printable p) {p.printString("愛生活愛Java");} }

3.2 方法引用符

3.3 方法引用類對象練習

將字符串轉成數值輸出

public interface Converter {int convert(String s); }public class ConverterDemo {public static void main(String[] args) {//在主方法中調用useConverter方法// useConverter((String s) -> { // return Integer.parseInt(s); // });useConverter(s -> Integer.parseInt(s));//引用類方法useConverter(Integer::parseInt);//Lambda表達式被類方法替代的時候，它的形式參數全部傳遞給靜態方法作為參數}private static void useConverter(Converter c) {int number = c.convert("666");System.out.println(number);} }

使用說明：

Lambda表達式被類方法替代的時候，它的形式參數全部傳遞給靜態方法作為參數

3.4 方法引用對象的實例方法

public class PrintString {//把字符串參數變成大寫的數據，然后在控制臺輸出public void printUpper(String s) {String result = s.toUpperCase();System.out.println(result);} }public interface Printer {void printUpperCase(String s); }public class PrinterDemo {public static void main(String[] args) {//在主方法中調用usePrinter方法// usePrinter((String s) -> { String result = s.toUpperCase(); System.out.println(result); // System.out.println(s.toUpperCase()); // });usePrinter(s -> System.out.println(s.toUpperCase()));//引用對象的實例方法PrintString ps = new PrintString();usePrinter(ps::printUpper);//Lambda表達式被對象的實例方法替代的時候，它的形式參數全部傳遞給該方法作為參數}private static void usePrinter(Printer p) {p.printUpperCase("HelloWorld");} }

使用說明：

Lambda表達式被對象的實例方法替代的時候，它的形式參數全部傳遞給該方法作為參數

3.5 方法引用類的實例方法

public interface MyString {String mySubString(String s,int x,int y); }public class MyStringDemo {public static void main(String[] args) {//在主方法中調用useMyString方法// useMyString((String s,int x,int y) -> { // return s.substring(x,y); // });useMyString((s,x,y) -> s.substring(x,y));//引用類的實例方法useMyString(String::substring);//Lambda表達式被類的實例方法替代的時候//第一個參數作為調用者//后面的參數全部傳遞給該方法作為參數}private static void useMyString(MyString my) {String s = my.mySubString("HelloWorld", 2, 5);System.out.println(s);} }

Lambda表達式被類的實例方法替代的時候 第一個參數作為調用者 后面的參數全部傳遞給該方法作為參數

3.6 引用構造方法

public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;} }public interface StudentBuilder {Student build(String name,int age); }public class StudentDemo {public static void main(String[] args) {//在主方法中調用useStudentBuilder方法// useStudentBuilder((String name,int age) -> { Student s = new Student(name,age); return s; // return new Student(name,age); // });useStudentBuilder((name,age) -> new Student(name,age));//引用構造器useStudentBuilder(Student::new);//Lambda表達式被構造器替代的時候，它的形式參數全部傳遞給構造器作為參數}private static void useStudentBuilder(StudentBuilder sb) {Student s = sb.build("Adrian", 18);System.out.println(s.getName() + "," + s.getAge());} }

Lambda表達式被構造器替代的時候，它的形式參數全部傳遞給構造器作為參數

總結

以上是生活随笔為你收集整理的【JavaSE】Lambda表达式、接口组成更新、方法引用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。