在數學中,函數就是有輸入量,輸出量的一套計算方案,也就是"拿數據做操作"
物件導向思想強調"必須通過物件的形式來做事情"
函數式思想則儘量忽略物件導向的複雜語法 : 「強調做什麼,而不是以什麼形式去做」
而我們要學習的Lambda表達式就是函數式思想的體現
需求: 啓動一個執行緒,在控制檯輸出一句話,多執行緒程式啓動了
方式1:
方式2:
方式3
匿名內部類中重新run()方法的程式碼分析
Lambda表達式的程式碼分析
組成Lambda表達式的三要素: 形式參數,箭頭,程式碼塊
Lambda表達式的格式
Lambda表達式的使用前提
練習1:
package com.itdemo_29;
public class EatableDemo {
public static void main(String[] args) {
//在主方法中呼叫useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
//匿名內部類
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一蘋果");
}
});
//Lambda表達式
useEatable(()->{
System.out.println("醫生遠離我");
});
}
private static void useEatable(Eatable e) {
e.eat();
}
}
練習2
public interface Flyable {
void fly(String s);
}
package com.itdemo_29;
public class FlyableDemo {
public static void main(String[] args) {
//在主方法中呼叫useFlyable方法
Flyable f = new FlyableImpl();
useFlyable(f);
//匿名內部類
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("自駕遊");
}
});
System.out.println("-------");
//Lambda
useFlyable((String s)->{
System.out.println(s);
System.out.println("日韓遊");
});
}
private static void useFlyable(Flyable f){
f.fly("風和日麗");
}
}
class FlyableImpl implements Flyable{
@Override
public void fly(String s) {
System.out.println("郊遊");
}
}
練習3:
public interface Addable {
int add(int x,int y);
}
package com.itdemo_29;
public class AddableDemo {
public static void main(String[] args) {
// Lambda
useAddable((int x,int y)->{
return x+y;
});
}
private static void useAddable(Addable a){
int sum = a.add(10, 29);
System.out.println(sum);
}
}
省略的規則
public interface Addable {
int add(int x,int y);
}
public interface Flyable {
void fly(String s);
}
package com.itdemo_29;
public class LambdaDemo01 {
public static void main(String[] args) {
useFlyable((String s)->{
System.out.println(s);
});
//如果參數只有一個,小括號可省略,參數型別可省略
useFlyable(s->{
System.out.println(s);
});
///如果程式碼塊的語句只有一條,可以省略大括號和分號
useFlyable(s-> System.out.println(s));
useAddable((int x,int y)->{
return x+y;
});
//參數型別要省略,都必須省略
useAddable((x,y)->{
return x+y;
});
//如果程式碼塊的語句只有一條,可以省略大括號和分號,如果有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);
}
}
package com.itdemo_29;
public class LambdaDemo02 {
public static void main(String[] args) {
useInter(()->{
System.out.println("好好學習");
});
//使用Lambda必須有介面, 並且要求介面中有且僅有一個抽象方法
useInter(()-> System.out.println("好好學習"));
//必須有上下文環境,才能 纔能推導出Lambda對應的介面
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名內部類");
}
}).start();
Runnable r = ()-> System.out.println("lambda表達式");
new Thread(r).start();
new Thread(()-> System.out.println("lambda表達式")).start();
}
private static void useInter(Inter i){
i.show();
}
}
所需型別不同
使用限制不同
實現原理不同
public abstract class Animal {
public abstract void method();
}
public interface Inter {
void show();
// void show2();
}
public class Student {
public void study(){
System.out.println("愛學習");
}
}
package com.itdemo_29;
public class LambdaDemo03 {
public static void main(String[] args) {
//匿名內部類
useInter(new Inter() {
@Override
public void show() {
System.out.println("介面");
}
});
// useAnimal(new Animal() {
// @Override
// public void method() {
// System.out.println("抽象類");
// }
// });
// useStudent(new Student(){
// @Override
// public void study() {
// System.out.println("具體類");
// }
// });
//lanbda
// useInter(()-> System.out.println("介面"));
// useAnimal(()-> System.out.println("抽象");//是介面型別
// useStudent(()-> System.out.println("具體類"));
//當有多個介面
// useInter(()-> System.out.println("介面"));
// useInter(new Inter() {
// @Override
// public void show() {
// System.out.println("show");
// }
//
// @Override
// public void show2() {
// System.out.println("show2");
// }
// });
}
private static void useStudent(Student s){
s.study();
}
private static void useAnimal(Animal a){
a.method();
}
private static void useInter(Inter i){
i.show();
}
}
介面的組成
public default void show3(){
}
public interface MyInterface {
void show1();
void show2();
//預設方法
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();
}
}
public class MyInterfaceImplOne implements MyInterface{
@Override
public void show1() {
System.out.println("One show1");
}
@Override
public void show2() {
System.out.println("One show2");
}
@Override
public void show3() {
System.out.println("One show3");
}
}
public class MyInterfaceImplTwe implements MyInterface{
@Override
public void show1() {
System.out.println("Two show1");
}
@Override
public void show2() {
System.out.println("Two show2");
}
}
介面中靜態方法的定義格式
public static void test(){}
介面中靜態方法的注意事項
public interface Flyable {
public static void test(){
System.out.println("Flyable的靜態方法");
}
}
public interface Inter {
//抽象方法
void show();
default void mothod(){
System.out.println("Inter中的預設方法");
}
static void test(){
System.out.println("Inter中的靜態方法");
}
}
public class InterImpl implements Inter{
@Override
public void show() {
System.out.println("實現類中show");
}
}
public class InterDemo {
public static void main(String[] args) {
//按照多型的方式建立物件使用
Inter i =new InterImpl();
i.show();
i.mothod();
//靜態方法不能通過實現類名或者物件呼叫
// i.test();
// InterImpl.test();
//只能通過介面名呼叫
Inter.test();
Flyable.test();
}
}
Java 9 新增了帶方法的私有方法,這其實在Java 8中就埋下了伏筆;Java8允許在介面中定義帶方法體的預設方法和靜態方法,這樣可能會引發一個問題: 當兩個預設方法或者靜態方法中包含一段相同的程式碼實現時,程式必然考慮將這段實現程式碼抽取成一個共性方法,而這個共性方法是不需要讓別人使用的,因此用私有給隱藏起來,這就是java9增加是由方法的必然性
介面中私有方法的定義格式:
介面中私有方法的注意事項
public interface Inter01 {
//預設方法
default void show1(){
System.out.println("show1開始執行");
// System.out.println("初級工程師");
// System.out.println("中級工程師");
// System.out.println("高階工程師");
// show();
method();
System.out.println("show1結束執行");
}
default 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 method(){
System.out.println("初級工程師");
System.out.println("中級工程師");
System.out.println("高階工程師");
}
}
public class InterImpl01 implements Inter01{
}
public class InterDemo01 {
public static void main(String[] args) {
//按照多型的方式建立物件並使用
Inter01 i = new InterImpl01();
i.show1();
Inter01.method1();
}
}
在使用Lambda表達式的時候, 我們實際上傳遞進去的程式碼就是一種解決方案: 拿參數做操作
那麼考慮一種情況: 如果我們在Lambda中所指定的操作方案,已經有地方存在相同的方案,那麼是否有必要在寫重複邏輯呢?
答案肯定是沒必要的
我們又是如何使用已經存在的方案的呢?
是通過方法參照的來使用已經存在的方案
package com.itdemo_30;
import com.itdemo_26.SystemOutDemo;
public class PrintableDemo {
public static void main(String[] args) {
usePrintable((String s)->{
System.out.println(s);
});
//簡化
usePrintable(s-> System.out.println(s));
//方法參照符::
usePrintable(System.out::println);
}
private static void usePrintable(Printable p){
p.printString("aishengho");
}
}
方法參照符
回顧一下我們在體驗方法參照中的程式碼
推導與省略
public interface Printable01 {
void printInt(int i);
}
public class PrintableDemo01 {
public static void main(String[] args) {
//使用lambda省略
usePrintable(i -> System.out.println(i));
//使用方法參照
usePrintable(System.out::println);
}
private static void usePrintable(Printable01 p) {
p.printInt(666);
}
}
常見參照方法
參照類方法: 其實就是參照型別的靜態方法
練習:
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("6666");
System.out.println(number);
}
}
參照物件的實體方法,其實就是參照類中的成員方法
練習:
public interface Printer {
void printUpperCase(String s);
}
public class PrintString {
public void printUpper(String s){
String result = s.toUpperCase();
System.out.println(result);
}
}
package com.itdemo_30;
public class PrinterDemo {
public static void main(String[] args) {
usePrinter((String s)->{
String result = s.toUpperCase();
System.out.println(result);
});
usePrinter(s-> System.out.println(s.toUpperCase()));
//參照物件的實體方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);
//Lambda表達式被物件的實體方法替代的時候,它的形式參數全部傳遞給該方法作爲參數
}
private static void usePrinter(Printer p){
p.printUpperCase("helloworld");
}
}
參照構造器,其實就是參照構造方法
練習:
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);
}
package com.itdemo_30;
public class StudnetDemo {
public static void main(String[] args) {
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 s){
Student s1 = s.build("萌萌",23);
System.out.println(s1.getName()+","+s1.getAge());
}
}
使用說明
Lambda表達式被構造器替代的時候,它的形式參數全部傳遞給構造器作爲參數