匿名类、匿名函数、函数式接口

1、函数式编程

函数是一个数学上的概念，表示一个集合到另一个集合的映射关系，这种关系在编程的时候通过箭头函数 (input)->{expression} 来表示，就是函数式编程

• 箭头的左边表示输入集合
• 右边表示整个函数的结果

2、函数式接口

函数式接口是只有一个抽象方法的接口，因此使用labmda函数重写方法的前提是该接口中有且仅有一个需要重写的抽象方法

• 通过匿名函数实现
• 通过匿名类实现

java的Runnable接口就是一个函数式接口，在Runable接口中只有一个抽象方法（那就是run()），其定义如下：

package java.lang;
@FunctionalInterface
public interface Runnable {
    public abstract void run();    
}

2.1 匿名类

Thread anonymousClassThread=new Thread(new Runnable() {
            @Override
            public void run()  {
                int count=1;
                while (count<5){
                    System.out.println("anonymousClassThread:"+count);
                    count++;
                    try {
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                    }
                }
            }
        });
        
anonymousClassThread.start();

2.2 匿名函数

Thread anonymousFunctionThread=new Thread(()->{
            int count=1;
            while (count<5){
                System.out.println("anonymousFunction:"+count);
                count++;
                try {
                    Thread.sleep(100);
                }catch (InterruptedException e){
                }
            }
        });
anonymousFunctionThread.start();

可以看出相对于匿名类的使用，匿名函数在使用上更加直观、简洁、也很易用。

除此之外，对方法参数为接口这种情况，也可以通过匿名函数轻便实现该接口

interface IFunctionCase{
    void func(String arg);
}

class FunctionCaseClass{
    public void funcTest(IFunctionCase f){
          System.out.println("before");
          f.func("test");
        System.out.println("after");
    }
}

FunctionCaseClass functionCaseClass=new FunctionCaseClass();
functionCaseClass.funcTest((arg)->System.out.println("a   "+arg));
functionCaseClass.funcTest((arg)->System.out.println("b  "+arg));

在java.util.function中，也有一些内置的函数式接口，这些函数式接口在jdk内置的lambda表示中被广泛的使用，主要包含下面四类:

• Function 返回一个新值
• Consumer 不返回值
• Supplier 没有输入，返回一个
• Predicate 返回一个布尔值
• 带Bi前缀的表示有多个输入的场景

3、额外的例子说明匿名函数

// 接口中只定义了1个抽象方法，可以利用Lambda表达式来重写这唯一的一个抽象方法
interface Cacl{
	public double add(double i, double j);
}


public class LambdaDemo {
	public static void main(String[] args) {
		
		
		// 方式一
		Cacl c = new Cacl() {
			@Override
			public double add(double i, double j) {
				return i + j;
			}	
		}; 
		
   		//方式2
   		// Lambda表达式只能作用在函数式接口上
		Cacl c = (double a, double b) -> {
     		return a + b;
       	}; 	// 这里必须加分号，结尾
      	// 方法体只有一句，可以省略{}和return不写
       Cacl c = (double i,double j) -> i + j;  
		
		
		
	 	// 方式3		
	    // 重写的是Cacl接口中的方法add，且add方法的参数列表的类型是已知的，可以省略参数类型不写
	   	Cacl c = (x, y) -> x + y;  // 可读性很差，看不到重写的是哪个方法
   
		
		System.out.println(c.add(5.6, 9.9));
	}
}

链接：https://www.jianshu.com/p/956a0464001c
链接：https://blog.csdn.net/u010199356/article/details/86622429