为什么要使用lamda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑
函数式接口
理解Functionalnterface (函数式接口)是学习Java8 lambda表达式的关键所在.
定义:
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
通过外部类实现接口
如下所示，在下面定义一个函数式接口，就是定义一个接口，定义一个方法，再定义一个实现类实现方法，再在main方法通过接口创建该实现类，调用实现方法。
/*** 推导lamada表达式*/
public class TestLambda1 {public static void main(String[] args) {testin testcl=new testcl();testcl.lambda();}
}//1.定义一个函数式接口
interface testin{void lambda();
}
//2.实现类
class testcl implements testin{@Overridepublic void lambda() {System.out.println("hello lambda");}
}成功输出
通过静态内部类实现接口
现在要想办法将其优化，将该实现类放到类的内部
在公共类内部定义一个静态内部类实现了接口,并且也没有问题。
/*** 推导lamada表达式*/
public class TestLambda1 {//3.静态内部类static class testcl2 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda2");}}public static void main(String[] args) {testin testcl=new testcl();testcl.lambda();testcl=new testcl2();testcl.lambda();}
}//1.定义一个函数式接口
interface testin{void lambda();
}
//2.实现类
class testcl implements testin{@Overridepublic void lambda() {System.out.println("hello lambda");}
}
通过局部内部类实现接口
在main方法内部实现外部接口。
/*** 推导lamada表达式*/
public class TestLambda1 {//3.静态内部类static class testcl2 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda2");}}public static void main(String[] args) {testin testcl=new testcl();testcl.lambda();testcl=new testcl2();testcl.lambda();//4.局部内部类class testcl3 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda3");}}testcl=new testcl3();testcl.lambda();}
}//1.定义一个函数式接口
interface testin{void lambda();
}
//2.实现类
class testcl implements testin{@Overridepublic void lambda() {System.out.println("hello lambda");}
}通过匿名内部类实现接口
在main方法内借助接口或者父类直接创建一个匿名实现类的实例，
/*** 推导lamada表达式*/
public class TestLambda1 {//3.静态内部类static class testcl2 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda2");}}public static void main(String[] args) {testin testcl=new testcl();testcl.lambda();testcl=new testcl2();testcl.lambda();//4.局部内部类class testcl3 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda3");}}testcl=new testcl3();testcl.lambda();//5.匿名内部类，没有类的名称，必须借助接口或者父类testcl= new testin(){@Overridepublic void lambda() {System.out.println("hello lambda4");}};testcl.lambda();}
}//1.定义一个函数式接口
interface testin{void lambda();
}
//2.实现类
class testcl implements testin{@Overridepublic void lambda() {System.out.println("hello lambda");}
}通过lambda表达式创建实现类
/*** 推导lamada表达式*/
public class TestLambda1 {//3.静态内部类static class testcl2 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda2");}}public static void main(String[] args) {testin testcl=new testcl();testcl.lambda();testcl=new testcl2();testcl.lambda();//4.局部内部类class testcl3 implements testin{@Overridepublic void lambda() {System.out.println("hello lambda3");}}testcl=new testcl3();testcl.lambda();//5.匿名内部类，没有类的名称，必须借助接口或者父类testcl= new testin(){@Overridepublic void lambda() {System.out.println("hello lambda4");}};testcl.lambda();//6.用lambda简化testcl=()->{System.out.println("hello lambda5");};testcl.lambda();}
}//1.定义一个函数式接口
interface testin{void lambda();
}
//2.实现类
class testcl implements testin{@Overridepublic void lambda() {System.out.println("hello lambda");}
}
简化过程
外部类->静态内部类->局部内部类->匿名内部类->lambda表达式
lambda只需要关注抽象方法的实现。
达到了使代码更简洁的要求，去掉了没有意义的代码，只留下了核心逻辑。
//6.用lambda简化testcl=()->{System.out.println("hello lambda5");};lombda实现带参数的接口并进行再次简化
和不带参数的相比就是在前面的括号里面加上了抽象方法的参数。
这里的两个简化都是可行的
public class TestLambda2 {public static void main(String[] args) {ILove love=(int a)->{System.out.println("I love you---->"+a);};//简化1.去除参数类型love=(a)->{System.out.println("I love you---->"+a);};//简化2.去除括号love= a->{System.out.println("I love you---->"+a);};//简化3.去除花括号love= a-> System.out.println("I love you---->"+a);//总结://lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行就要用代码块包裹。//前提是必须是函数式接口(只有一个方法)//多个参数也可以去掉参数类型，要去掉就都去掉，但必须加上括号love.love(2);}
}
interface ILove{void love(int a);
}
总结:lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行就要用代码块包裹。前提是必须是函数式接口(只有一个方法) 多个参数也可以去掉参数类型，要去掉就都去掉，但必须加上括号
