Lamda表达式
为什么要使用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{
@Override
public void lambda() {
System.out.println("hello lambda");
}
}成功输出
通过静态内部类实现接口
现在要想办法将其优化，将该实现类放到类的内部
在公共类内部定义一个静态内部类实现了接口,并且也没有问题。
/**
* 推导lamada表达式
*/
public class TestLambda1 {
//3.静态内部类
static class testcl2 implements testin{
@Override
public 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{
@Override
public void lambda() {
System.out.println("hello lambda");
}
}
通过局部内部类实现接口
在main方法内部实现外部接口。
/**
* 推导lamada表达式
*/
public class TestLambda1 {
//3.静态内部类
static class testcl2 implements testin{
@Override
public 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{
@Override
public void lambda() {
System.out.println("hello lambda3");
}
}
testcl=new testcl3();
testcl.lambda();
}
}
//1.定义一个函数式接口
interface testin{
void lambda();
}
//2.实现类
class testcl implements testin{
@Override
public void lambda() {
System.out.println("hello lambda");
}
}通过匿名内部类实现接口
在main方法内借助接口或者父类直接创建一个匿名实现类的实例，
/**
* 推导lamada表达式
*/
public class TestLambda1 {
//3.静态内部类
static class testcl2 implements testin{
@Override
public 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{
@Override
public void lambda() {
System.out.println("hello lambda3");
}
}
testcl=new testcl3();
testcl.lambda();
//5.匿名内部类，没有类的名称，必须借助接口或者父类
testcl= new testin(){
@Override
public void lambda() {
System.out.println("hello lambda4");
}
};
testcl.lambda();
}
}
//1.定义一个函数式接口
interface testin{
void lambda();
}
//2.实现类
class testcl implements testin{
@Override
public void lambda() {
System.out.println("hello lambda");
}
}通过lambda表达式创建实现类
/**
* 推导lamada表达式
*/
public class TestLambda1 {
//3.静态内部类
static class testcl2 implements testin{
@Override
public 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{
@Override
public void lambda() {
System.out.println("hello lambda3");
}
}
testcl=new testcl3();
testcl.lambda();
//5.匿名内部类，没有类的名称，必须借助接口或者父类
testcl= new testin(){
@Override
public 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{
@Override
public 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表达式只能有一行代码的情况下才能简化成一行，如果有多行就要用代码块包裹。
前提是必须是函数式接口(只有一个方法)
多个参数也可以去掉参数类型，要去掉就都去掉，但必须加上括号