java 匿名函数 构造_Java匿名内部类与Lambda表达式

匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

实例1:不使用匿名内部类来实现抽象方

1 abstract classPerson {2 public abstract voideat();3 }4

5 class Child extendsPerson {6 public voideat() {7 System.out.println("eat something");8 }9 }10

11 public classDemo {12 public static voidmain(String[] args) {13 Person p = newChild();14 p.eat();15 }16 }

运行结果：eat something

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用

但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类

实例2：匿名内部类的基本实现

1 abstract classPerson {2 public abstract voideat();3 }4

5 public classDemo {6 public static voidmain(String[] args) {7 Person p = newPerson() {8 public voideat() {9 System.out.println("eat something");10 }11 };12 p.eat();13 }14 }

运行结果：eat something

可以看到，我们直接将抽象类Person中的方法在大括号中实现了

这样便可以省略一个类的书写

并且，匿名内部类还能用于接口上

实例3：在接口上使用匿名内部类

1 interfacePerson {2 public voideat();3 }4

5 public classDemo {6 public static voidmain(String[] args) {7 Person p = newPerson() {8 public voideat() {9 System.out.println("eat something");10 }11 };12 p.eat();13 }14 }

运行结果：eat something

由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

实例4：Thread类的匿名内部类实现

1 public classDemo {2 public static voidmain(String[] args) {3 Thread t = newThread() {4 public voidrun() {5 for (int i = 1; i <= 5; i++) {6 System.out.print(i + " ");7 }8 }9 };10 t.start();11 }12 }

运行结果：1 2 3 4 5

实例5：Runnable接口的匿名内部类实现

1 public classDemo {2 public static voidmain(String[] args) {3 Runnable r = newRunnable() {4 public voidrun() {5 for (int i = 1; i <= 5; i++) {6 System.out.print(i + " ");7 }8 }9 };10 Thread t = newThread(r);11 t.start();12 }13 }

运行结果：1 2 3 4 5

Lambda表达式

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

1 /**多参数无返回*/

2 @FunctionalInterface3 public interfaceNoReturnMultiParam {4 void method(int a, intb);5 }6

7 /**无参无返回值*/

8 @FunctionalInterface9 public interfaceNoReturnNoParam {10 voidmethod();11 }12

13 /**一个参数无返回*/

14 @FunctionalInterface15 public interfaceNoReturnOneParam {16 void method(inta);17 }18

19 /**多个参数有返回值*/

20 @FunctionalInterface21 public interfaceReturnMultiParam {22 int method(int a, intb);23 }24

25 /*** 无参有返回*/

26 @FunctionalInterface27 public interfaceReturnNoParam {28 intmethod();29 }30

31 /**一个参数有返回值*/

32 @FunctionalInterface33 public interfaceReturnOneParam {34 int method(inta);35 }

1 import lambda.interfaces.*;2

3 public classTest1 {4 public static voidmain(String[] args) {5

6 //无参无返回

7 NoReturnNoParam noReturnNoParam = () ->{8 System.out.println("NoReturnNoParam");9 };10 noReturnNoParam.method();11

12 //一个参数无返回

13 NoReturnOneParam noReturnOneParam = (int a) ->{14 System.out.println("NoReturnOneParam param:" +a);15 };16 noReturnOneParam.method(6);17

18 //多个参数无返回

19 NoReturnMultiParam noReturnMultiParam = (int a, int b) ->{20 System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");21 };22 noReturnMultiParam.method(6, 8);23

24 //无参有返回值

25 ReturnNoParam returnNoParam = () ->{26 System.out.print("ReturnNoParam");27 return 1;28 };29

30 int res =returnNoParam.method();31 System.out.println("return:" +res);32

33 //一个参数有返回值

34 ReturnOneParam returnOneParam = (int a) ->{35 System.out.println("ReturnOneParam param:" +a);36 return 1;37 };38

39 int res2 = returnOneParam.method(6);40 System.out.println("return:" +res2);41

42 //多个参数有返回值

43 ReturnMultiParam returnMultiParam = (int a, int b) ->{44 System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");45 return 1;46 };47

48 int res3 = returnMultiParam.method(6, 8);49 System.out.println("return:" +res3);50 }51 }

lambda 表达式创建线程

我们以往都是通过创建 Thread 对象，然后通过匿名内部类重写 run() 方法，一提到匿名内部类我们就应该想到可以使用 lambda 表达式来简化线程的创建过程。

1 Thread t = new Thread(() ->{2 for (int i = 0; i < 10; i++) {3 System.out.println(2 + ":" +i);4 }5 });6 t.start();

1 Runnable r = ->{2 for (int i=0;i<10;i++){3 System.out.println(2 + "." +i);4 }5 };6 Thread t = new Thread(r);

构造方法的引用

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

1 interfaceItemCreatorBlankConstruct {2 Item getItem();3 }4 interfaceItemCreatorParamContruct {5 Item getItem(int id, String name, doubleprice);6 }7

8 public classExe2 {9 public static voidmain(String[] args) {10 ItemCreatorBlankConstruct creator = () -> newItem();11 Item item =creator.getItem();12

13 ItemCreatorBlankConstruct creator2 = Item::new;14 Item item2 =creator2.getItem();15

16 ItemCreatorParamContruct creator3 = Item::new;17 Item item3 = creator3.getItem(112, "鼠标", 135.99);18 }19 }

lambda 表达式引用方法

有时候我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法。

语法

​ 方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象

1 public classExe1 {2 public static voidmain(String[] args) {3 ReturnOneParam lambda1 = a ->doubleNum(a);4 System.out.println(lambda1.method(3));5

6 //lambda2 引用了已经实现的 doubleNum 方法

7 ReturnOneParam lambda2 =Exe1::doubleNum;8 System.out.println(lambda2.method(3));9

10 Exe1 exe = newExe1();11

12 //lambda4 引用了已经实现的 addTwo 方法

13 ReturnOneParam lambda4 =exe::addTwo;14 System.out.println(lambda4.method(2));15 }16

17 /**

18 * 要求19 * 1.参数数量和类型要与接口中定义的一致20 * 2.返回值类型要与接口中定义的一致21 */

22 public static int doubleNum(inta) {23 return a * 2;24 }25

26 public int addTwo(inta) {27 return a + 2;28 }29 }