多线程-lambda表达式（无参用法，多参用方法，常规用法）

希腊字母表中排序第十一位的字母，英文名称为： lambda

其实质属于涵数编程的概念。

为什么要使用：

　　为了避免匿名内部类定义过多

　　可以让你的代码看越来很简洁

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

理解Functional lnterface(涵数式接口)是学习java8,lambda表达式的关键所在。
涵数式掊的定义：
            任何接口，如果只包含唯一一个抽象方法，那么它就一个涵数式接口。如：

　　　　　　　　pulbic imterface Runnable{
　　　　　　　　　　public abstract void run();

　　　　　　　　　　}

　　　　　　　　对于涵数式接口，我们可以通过lambda表达式来创建该接口的对象

/*推导： lambda表达式*/

//无参的方法使用lambda表达式
public class Main {
    //2.简化第一种方式的代码：使用静态内部类
    static class Like2 implements ILike{
    //重写接口的方法
    public void lambda(){
        System.out.println("i like lambda2");
        
    }
}
    
    public static void main(String[] args) {
        //1.1：创建接口对象，然后实现类指向接口
        ILike like=new Like();
        like.lambda();
        
        //2.2使用静态内部类调用 
        like=new Like2();
        like.lambda();
        
        
        //3.简化第二种方式的代码，使用局部内部类
        class Like3 implements ILike{
    //重写接口的方法
    public void lambda(){
        System.out.println("i like lambda3");
        
    }
}   
        //3.1使用局部内部类去调用实现类的方法
        like=new Like3();
        like.lambda();
        
        
        //4.简化第三种方式的代码，使用匿名内部类,没有类的名称，必须借助接口或者父类
        like =new ILike(){
            public void lambda(){
                System.out.println("i like lambda4");
            }
        };
        //4.1调用方法
        like.lambda();    
        
        //5.简化第四种方式的代码，使用lambda表达式简化
        like=()->{
                System.out.println("i like lambda5");//涵数式接口的核心代码，直接把实现类重写方法的括号及后面的代码复制过来就可以了，参数括号中间与方法体的括号加个箭头即可加
            };
            
            like.lambda();
        
    }
}

//1.第一种方式写的代码：定义一个涵数式接口
interface ILike{
    void lambda();
}

//实现类
class Like implements ILike{
    //重写接口的方法
    public void lambda(){
        System.out.println("i like lambda");
        
    }
}

import java.util.Scanner;
//有参的方法使用lambda表达式
public class Main {
    //使用静态内部实现方法二,这样我们就不用在像方式一一样创建一个实现类去重载方法了,直接在main方法中，创建接口类指向实现类的对象再使用内部类简化就可以了，2，3，4方式也是不用实现类
    static class Love implements Ilove{
    public void love(int a){
        System.out.println("i lvoe you2-->"+a);
    }
}
    
    public static void main(String[] args) {
        //接口new实现类,最初的实现方法:方式一
        Ilove lvoe=new Love();
        lvoe.love(1);
        
        //方式二：使用静态内部类实现，直接调用就可以了
        lvoe.love(2);
        
        //方式三：使用局部内部类
        class Love implements Ilove{
    public void love(int a){
        System.out.println("i lvoe you3-->"+a);
     }
        };
        lvoe.love(3);

        //方式四：使用匿名内部类,直接new接口
        lvoe=new  Ilove(){
            public void love(int a){
        System.out.println("i lvoe you4-->"+a);
    }
        };
        
        lvoe.love(4);
        
        //方式五：使用lambda表达式处理
        lvoe=(int a)->{//去了方法，只保留实现
        System.out.println("i lvoe you5-->"+a);
     };
     lvoe.love(5);
     
     //方式五1：再次简化lambda代码,简化1
     lvoe=(a)->{//简化参数类型，去掉参数类型
        System.out.println("i lvoe you5-->"+a);
     };
     lvoe.love(6);
     
     //方式五2：再次简化lambda代码，简化2
     lvoe=a->{//简化括号
         System.out.println("i lvoe you5-->"+a);
     };
     
     lvoe.love(7);
     
      //方式五3：再次简化lambda代码，简化3
     lvoe=a->//简化花括号，如代码好多行，就不减去花括号，只有一行就可以
         System.out.println("i lvoe you5-->"+a);
         lvoe.love(8);
         //总结： lambda表达式，只能有一行代码的情况下才能简化成一行，如果有多行，就必须用代码块去包裹
                //提前是接口为涵数式接口
                //多个参数也可以去掉参数类型，要去掉就都去除
    }
}
//接口：涵数式接口
interface Ilove{
    void love(int a);
}
class Love implements Ilove{
    
    //重写方法
    public void love(int a){
        System.out.println("i lvoe you1-->"+a);
    }
}

import java.util.Scanner;
//常规用法
public class Main {
    public static void main(String[] args) {
        //创建接口类对象
       Ilove lvoe=null;
       
        //使用lambda表达式处理
        lvoe=(int a)->{//去了方法，只保留实现
        System.out.println("i lvoe you-->"+a);
     };
     lvoe.love(5);
    }
}
//接口：涵数式接口
interface Ilove{
    void love(int a);
}

java之多线程

多线程-lambda表达式（无参用法，多参用方法，常规用法）

相关

标签