Lambda -- 01基础

目录

静态代理模式

策略模式

lambda思想

匿名内部类

lambda语法糖

行为参数化

函数名

就一个抽象方法的接口：函数式接口

lambda表达式

---

谈Lambda之前，先讲讲静态代理模式，以及策略模式，然后我们在逐步进入正题，lambda思想是怎么一步步的由传统的java编程演变而来的。

静态代理模式

看示例代码：

class MyTask implements Runnable 
{
	public void run(){
		System.out.println("hello world");
	}
}

public class TestStaticProxy
{
	public static void main(String[] args){
		Runnable task = new MyTask();
		Thread t = new Thread(task,"myThread");
		t.start(); //这里仅仅调用了线程t启动，怎么就能执行MyTask类的run()方法了呢？
	}
}

以上示例，运行，输出 hello world

程序的执行，从上至下执行的顺序结构，来看问题。main()方法是java程序运行的入口，程序执行到 t.start()；这一句，表示一个新线程启动了，然后主线程main就执行完退出了，那么这个MyTask类的run()方法是什么时候被调用，又是被谁调用的呢？答：这就是静态代码模式的运用了，线程t启动后，t的start()会内部调用task对象(MyTask类类型)的run()方法，可以理解为t.start(){ task.run(); }。我们可以说，task对象的run()方法托管给了线程t的start()方法内部来调用，专业术语：这就叫“静态代理模式”---执行的是A方法，A方法的内部会调用X对象的B方法，X对象的B方法被静态代理。

策略模式

 看示例代码：

这里我举例数据库的一张表来描述策略模式思想，感觉更贴切些，假定有这么一张表，表示食谱表，食谱表中的每行记录，代表每道菜。对应到java里面，就是表中的每行记录(/每道菜)都是一个java的值vo对象，也即所谓的普通POJO对象。整张表呢就是一个List集合。让我们看看示例：

数据库表Dish表中的每行记录，都是一道菜

//数据库表Dish表中的每行记录，都是一道菜
public class Dish { 
    private final String name;         //菜名
    private final boolean vegetarian;  //是否素菜
    private final int calories;        //菜还有的热量
    private final Type type;           //菜的类型
 
    public Dish(String name, boolean vegetarian, int calories, Type type) { 
        this.name = name; 
        this.vegetarian = vegetarian; 
        this.calories = calories; 
        this.type = type; 
    } 

    public String getName() { return name; } 
    public boolean isVegetarian() { return vegetarian; } 
    public int getCalories() { return calories; } 
    public Type getType() { return type; } 

    public String toString() { return name; }

    public enum Type { MEAT, FISH, OTHER } 
} 

Dish表中的全部记录，构成了一份食谱，也即所有菜的集合

import java.util.*;

//Dish表的所有记录，构成了一份食谱，也即菜的集合
List<Dish> dishes = Arrays.asList( 
    new Dish("pork", false, 800, Dish.Type.MEAT), 
    new Dish("beef", false, 700, Dish.Type.MEAT), 
    new Dish("chicken", false, 400, Dish.Type.MEAT), 
    new Dish("french fries", true, 530, Dish.Type.OTHER), 
    new Dish("rice", true, 350, Dish.Type.OTHER), 
    new Dish("season fruit", true, 120, Dish.Type.OTHER), 
    new Dish("pizza", true, 550, Dish.Type.OTHER), 
    new Dish("prawns", false, 300, Dish.Type.FISH), 
    new Dish("salmon", false, 450, Dish.Type.FISH) 
);

好，现在假定我们有了上方的食谱(/也即我们去吃饭时的菜单)，我们接着引入如下诉求：

• 区分出来哪些是素菜
• 区分出来哪些菜含的热量>400
• 区分出来哪些菜是FISH类别的
• ......如果菜对象携带有更多的属性信息，客户无穷无尽的针对属性要求区分

让我们先用传统的手法针对客户的诉求来实现：

//区分出哪些是素菜
public static List<Dish> filterIsVegetarianDishes(List<Dish> dishes) { 
    List<Dish> result = new ArrayList<Dish>(); 
    for(Dish dish: dishes)
        if( dish.isVegetarian() )
            result.add(dish); 
    return result; 
} 

//区分出哪些菜是含热量>400的
public static List<Dish> filterCalories400Dishes(List<Dish> dishes) { 
    List<Dish> result = new ArrayList<Dish>(); 
    for(Dish dish: dishes)
        if( dish.getCalories() > 400 )
            result.add(dish); 
    return result; 
}

//区分出哪些菜是FISH类别的
public static List<Dish> filterTypeFISHDishes(List<Dish> dishes) { 
    List<Dish> result = new ArrayList<Dish>(); 
    for(Dish dish: dishes)
        if( dish.getType().equals(Dish.Type.FISH) )
            result.add(dish); 
    return result; 
}

 。。。。。。客户无穷无尽的区分诉求，难道我们也要添加无穷无