什麼是函式式(Functional)介面

l 只包含一個抽象方法的介面，稱為 函式式介面 。 l 你可以通過 Lambda 表示式來建立該介面的物件。（若 Lambda 表示式丟擲一個受檢 異常 ( 即：非執行時異常 ) ， 那麼該異常需要在目標介面的抽象方法上進行宣告）。 l 我們可以 在 一個 介面 上使用 @ FunctionalInterface 註解，這樣做可以檢查它是否是一個函式式 介面。同時 javadoc 也會包含一條宣告，說明這個介面是一個函式式 介面。 l 在 java.util.function 包下定義了 java 8 的豐富的函式式介面 如何理解函式式介面

Java從誕生日起就是一直倡導“一切皆物件”，在java裡面面向物件(OOP)程式設計是一切。但是隨著python、scala等語言的興起和新技術的挑戰，java不得不做出調整以便支援更加廣泛的技術要求，也即java不但可以支援OOP還可以支援OOF（面向函式程式設計）

在函數語言程式設計語言當中，函式被當做一等公民對待。在將函式作為一等公民的程式語言中，Lambda表示式的型別是函式。但是在Java8中，有所不同。在

Java8中，Lambda表示式是物件，而不是函式，它們必須依附於一類特別的物件型別——函式式介面。

簡單的說，在Java8中，Lambda表示式就是一個函式式介面的例項。這就是Lambda表示式和函式式介面的關係。也就是說，只要一個物件是函式式介面的例項，那麼該物件就可以用Lambda表示式來表示。

所以以前用匿名內部類表示的現在都可以用Lambda表示式來寫。

Java 內建四大核心函式式介面

其它介面

package day26_1;

import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

import org.junit.Test;

/**
 * 函式式介面 ： 只有一個抽象方法的介面， 關注的是方法的行為模式
 * Consumer<T> 消費器， 消費一個T型別的物件
 * 		void accept(T t); -> 有參無返回， 有輸入沒有輸出
 * 
 * Supplier<T> 供給器，返回一個T型別的物件
 * 		T get(); -> 無參有返回， 沒有輸入， 有輸出
 * 
 * Function<T, R> 轉換器， 輸入一個T型別的物件， 經過某種處理返回一個R型別的物件
 * 		R apply(T t); -> 有參有返回， 有輸入， 有輸出
 * 
 * Predicate<T> 斷定器 ， 輸入一個T型別的物件， 經過某種判斷後返回真或假
 * 		boolean test(T t); -> 有參有固定的返回型別（boolean) 
 * 
 * BinaryOperator<T> 二元運算操作， 輸入2個T型別的物件， 經過某種處理後返回一個T型別的物件
 * 		T apply(T t1, T t2);
 * 
 * 方法引用 ： 適用於方法的模式一樣， 有幾個輸入， 有沒有輸出。
 */
public class FunctionalInterfaceTest {
	
	@Test
	public void test9() {
		Supplier<Student> supplier1 = () -> new Student();
		Supplier<Student> supplier2 = Student::new; // 構造器引用
		
		System.out.println(supplier2.get());
	}
	
	@Test
	public void test8() {
		new Supplier<Double>() {
			@Override
			public Double get() { // 無參有返回
				return Math.random();
			}
		};
		// lambda表示式
		Supplier<Double> supplier1 = () -> Math.random();
		// 方法引用
		Supplier<Double> supplier2 = Math::random;
		
		System.out.println(supplier1.get());
		System.out.println(supplier2.get());
	}
	
	@Test
	public void test7() {
		new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		};
		Consumer<String> consumer1 = t -> System.out.println(t);
		Consumer<String> consumer2 = System.out::println; // ::表示類或物件的方法
	}
	
	@Test
	public void tes6() {
		// 獲取兩個學生中分數最高的。
		BinaryOperator<Student> binaryOperator = (t1, t2) -> t1.getScore() > t2.getScore() ? t1 : t2;
		Student s1 = new Student(1, "小明", 3, 50);
		Student s2 = new Student(2, "小麗", 2, 80);
		
		Student apply = binaryOperator.apply(s1, s2);
		System.out.println(apply);
	}
	@Test
	public void test5() {
		BinaryOperator<String> binaryOperator = new BinaryOperator<String>() {
			@Override
			public String apply(String t, String u) {
				return t + u;
			}
		};
		
		String apply = binaryOperator.apply("safljsfljk", "xxxxx191923");
		System.out.println(apply);
		
		BinaryOperator<String> binaryOperator2 = (t1, t2) -> t1 + t2;
		String apply2 = binaryOperator2.apply("a324234", "我是漢字");
		System.out.println(apply2);
	}
	
	@Test
	public void test4() {
		Predicate<String> predicate1 = new Predicate<String>() {
			@Override
			public boolean test(String t) {
				return t.endsWith(".java");
			}
		};
		boolean test1 = predicate1.test("hello.abc");
		System.out.println(test1);
		
		// lambda表示式
		Predicate<String> predicate2 = t -> t.endsWith(".java");
		boolean test2 = predicate2.test("hello.java");
		System.out.println(test2);
	}
	
	
	@Test
	public void test3() {
		Function<Double, Integer> function1 = new Function<Double, Integer>() {
			@Override
			public Integer apply(Double t) {
				return t.intValue();
			}
		};
		
		Integer num1 = function1.apply(3.94159);
		System.out.println(num1);
		
		// lambda 表達 
		Function<Double, Integer> function2 = t -> t.intValue(); 
		Integer num2 = function2.apply(9.2324);
		System.out.println(num2);
	}
	
	@Test
	public void test2() {
		Supplier<Integer> supplier1 = new Supplier<Integer>() {
			@Override
			public Integer get() {
				return 200;
			}
		};
		
		Integer integer = supplier1.get();
		System.out.println(integer);
		
		Supplier<Integer> supplier2 = () -> 200;
		Integer integer2 = supplier2.get();
		System.out.println(integer2);
	}
	
	@Test
	public void test1() {
		Consumer<String> consumer = new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		};
		
		consumer.accept("afljaslfjalksjf");
		
		Consumer<Integer> consumer2 = t -> System.out.println(t);
		consumer2.accept(234238); // 消費器
		
	}
}

package day26_1;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

import org.junit.Test;

public class FunctionalInterfaceExer {
	
	@Test
	public void exer4() {
		// 寫一個判定器， 輸入一個學生物件， 判定他是否及格了。
		Predicate<Student> predicate1 = new Predicate<Student>() {
			@Override
			public boolean test(Student t) {
				return t.getScore() >= 60;
			}
		};
		Student student = new Student(1, "小明", 5, 1.5);
		boolean test = predicate1.test(student);
		System.out.println(test);
		
		// Lambda表示式
		Predicate<Student> predicate2 = t -> t.getScore() >= 60;
		System.out.println(predicate2.test(student));
	}
	
	@Test
	public void exer3() {
		// 寫一個轉換器， 把學生物件轉換成一個Double
		Function<Student, Double> fun1 = new Function<Student, Double>() {
			@Override
			public Double apply(Student t) {
				return t.getScore();
			}
		};
		Student student = new Student(1, "小明", 5, 80.5);
		Double apply = fun1.apply(student);
		System.out.println(apply);
		
		// lambda表示式
		Function<Student, Double> fun2 = t -> t.getScore();
		Double apply2 = fun2.apply(student);
		System.out.println(apply2);
	}
	
	// 做一個練習 ： 使用供給器獲取一個Student物件， 再使用消費型器這個物件列印輸出。
	@Test
	public void exer2() {
		Supplier<Student> supplier1 = new Supplier<Student>() {
			@Override
			public Student get() {
				return new Student();
			}
		};
		
		Student student = supplier1.get();
		Consumer<Student> consumer1 = new Consumer<Student>() {
			@Override
			public void accept(Student t) {
				System.out.println(t);
			}
		};
		consumer1.accept(student);
		
		// lambda表示式
		Supplier<Student> supplier2 = () -> new Student();
		Student student2 = supplier2.get();
		Consumer<Student> consumer2 = t -> System.out.println(t);
		consumer2.accept(student2);
		
	}
	
	@Test
	public void exer1() {
		// 做一個供給器， 每呼叫一次獲取一個隨機100以內的整數。
		Supplier<Integer> supplier1 = new Supplier<Integer>() {
			@Override
			public Integer get() {
				return (int)(Math.random() * 100);
			}
		};
		
		Integer num = supplier1.get();
		System.out.println(num);
		
		// lambda表示式
		Supplier<Integer> supplier2 = () -> (int)(Math.random() * 100);
		
		Integer num2 = supplier2.get();
		System.out.println(num2);
	}
}
 

相關推薦