lambda表达式(1.8新特性)

lambda表达式

Lambda表达式：
◆入希腊字母表中排序第十- -位的字母，英语名称为Lambda
◆避免匿名内部类定义过多
◆其实质属于函数式编程的概念

例子：new Thread ()->System.out.println(“多线程学习。 。。。")) .start();

简化转换过程

1.类(普通)

//1.实现一个函数式接口
public interface Lambda{
    void lambda();
}
//2.实现类
public class LambdaClass implements Lambda{
    @Override
    public void lambda() {
        System.out.println("类(普通)");
    }
}
//3.创建实例，调用
public class TestLambda {
    public static void main(String[] args) {
            Lambda L1 = new LambdaClass();
            L1.lambda();
    }
}

2.(静态内部类)

public interface Lambda{    //函数式接口
    void lambda();
}
 //在类中用static修饰的类
static class LambdaClass implements Lambda{     //静态内部类（实现类）
    @Override
    public void lambda() {
        System.out.println("静态内部类");
    }
}
public static void main(String[] args) {        //创建实例，调用
    Lambda L1 = new LambdaClass();
    L1.lambda();
}

3.(局部内部类)

public interface Lambda{    //函数式接口
    void lambda();
}
public static void main(String[] args) {
    //局部内部类   在方法的类里称为局部内部类。
    class LambdaClass implements Lambda {       //局部内部类（实现类）
        @Override
        public void lambda() {
            System.out.println("局部内部类");
        }
    }
    Lambda L1 = new LambdaClass();              //创建实例，调用
    L1.lambda();
}

4.(匿名内部类)

public interface Lambda{    //函数式接口
    void lambda();
}

public static void main(String[] args) {
    //匿名内部类:没有类的名称,必须借助接口或者父类,在方法的类里称为局部内部类。
    L1 = new Lambda() {                         //匿名内部类（实现类）
        @Override
        public void lambda() {
            System.out.println("匿名内部类");
        }
    };
    L1.lambda();                                //调用
}

5.(lambda表达式)

public interface Lambda{    //函数式接口
    void lambda();
}
L1 = ()->{                                  //lambda表达式
    System.out.println("lambda表达式");
};
L1.lambda();                                //调用

5.1(lambda表达式传参以及简化)

public interface Lambda{    //函数式接口
    void lambda(int a);
}
L1 = (int a)->{                     //lambda表达式（需要函数式接口）        
    System.out.println("lambda表达式,参数数字-->"+a);
};
L1.lambda(123456789);//调用

L2 = (a)->{                 //简化1，简化参数类型（当有多个参数时，参数类型都写或都不写）
    System.out.println("lambda表达式,参数数字-->"+a);
};
L2.lambda(123456789);//调用   
L3 = a->{                   //简化2,简化括号（当有多个参数需要加括号）
    System.out.println("lambda表达式,参数数字-->"+a);
};
L3.lambda(123456789);//调用
                            //简化3，简化花括号（当有多行代码需要加花括号。一个分号;代表一行代码）
L4 = a->System.out.println("lambda表达式,参数数字-->"+a);
L4.lambda(123456789);//调用