2021-06-29

多线程-lambda表达式

1. 函数式接口的定义

   任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口

   对于函数式接口，我们可以通过lambda表达式来创建该接口的对象,其实质是函数接口的概念

   public interface runnable{
       public abstract void run();
   }
   

2. 为什么要使用lambda表达式

   避免匿名内部类定义过多

   简洁化代码

   去掉一堆没有意义的代码，只留下核心的逻辑

3. lambda的推导过程

静态内部类

• 静态内部类，不能访问外部类的非静态成员
• 静态内部类 不需要创建外部类的对象就可访问（外部类名.内部类 比如new MyMain.Person().display();就创建了静态内部类对象）
• 静态内部类可以有public、protected、默认的、private等多种类型

接口引用的类的对象

• 接口 对象名 = new 类(); //首先这个类实现了这个接口
• 用接口类型去引用对象，只能调用接口中的方法，不能调用类中的特有方法，而接口不能实例化

//原始
public class TestLambda {     
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

// 1.定义一个函数式接口
interface ILike {
    void lambda();
}

// 2.实现类
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I Like lambda");
    }
}

结果：

I Like lambda

look down

Like在main函数的类的外面很麻烦——>静态内部类
public class TestLambda1{
	static class Like implements ILike{
	@override
	public void lambda(){
	    System.out.println("I Like lambda");
	}
	}   
    public static void main(String[] args) {
        like = new Like();
        like.lambda();
    }
}
interface ILike {
    void lambda();
}

I Like lambda
运行报Exception in thread "main" java.lang.Error: Unresolved compilation problem:
看是否忘记引入包路径，修改文件名和主类名

look down

局部内部类、、类放在方法里面
public class TestLambda1{ 
    public static void main(String[] args) {
      
        //局部内部类  
        class Like implements ILike{
		@override
		public void lambda(){
	    System.out.println("I Like lambda");
	}}
        Like like = new Like();
        like.lambda();
    }
}
interface ILike {
    void lambda();
}

I Like lambda
运行报  Illegal modifier for the local class Lk; only abstract or final is permitted 错
//类名改了，对象定义时的类名没改，局部内部类不能用static关键字修饰

look down

package com.md.st.rece;
public class Test1{ 
    public static void main(String[] args) {
      
//匿名内部类，无class无类名的类，必须借助接口或者父类，重写方法
       ILike like = new ILike(){
            @Override
           public void lambda(){
           System.out.println("I Like lambda");
           }
       };
        like.lambda();
    }
}
interface ILike {
    void lambda();
}

I Like lambda
执行保错 likecannot be resolved to a variable
        like cannot be resolved
匿名内部类的创建有问题
new 类名(参数)|实现接口(){}
ILike like = new ILike() 不报错
like = new ILike()保错

look down

//用lambda简化，因为表达式的前提就是，接口是函数式接口，接口里面的方法就只有一个，所以可以简化
package com.md.st.rece;
public class Test1{ 
    public static void main(String[] args) {
      	ILike like = ()->{//要加上接口
           System.out.println("I Like lambda");
        };//要加上";"
        like.lambda();
    }
}
interface ILike {
    void lambda();
}

I Like lambda

package com.md.st.rece;
public class Test1{ 
public static void main(String[] args) {
    //ILove love = new ILove(){
      //  @Override
        //匿名内部类
       // public void love(int a){
         //   System.out.println("I love you->"+a);
        //}
   // };
    ILove love = (int a)->{
//接口 对象名 = (函数式接口的方法中的参数)->{接口中的方法内容}
//有时可以简化为love = (a)->
       System.out.println("I love you->"+a);
    };
    love.love(2);
}
}
interface ILove{
    void love(int a);
}