多线程10：Lamda表达式

Lambda表达式

• 避免匿名内部类定义过多

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

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

 

• 理解Functional Interface（函数式接口）是Java8 lambda表达式关键所在

• 函数式接口的定义：

  • 任何接口，如果只包含一个抽象方法，那么他就是一个函数式接口

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

     

package com.HuoLong.lambda;
​
/*
推导lambda表达式
* */
public class TestLambda1 {
​
    //3静态内部类 +static
   static class Like2 implements ILike{//
​
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }
​
​
​
    public static void main(String[] args) {
        ILike like= new Like();//父类接口的引用指向子类对象,多态
        like.lambda();
​
       like =new Like2();//重用上一个变量‘like’声明
       like.lambda();
​
       //4.局部内部类  方法内部
        class Like3 implements ILike{
​
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like=new Like3();
        like.lambda();
​
        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        like=new ILike() {//new jiekou
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };//;
        like.lambda();
​
        //6.用lambda简化
        like=() ->{
            System.out.println("i like lambda5");
        };//;
        like.lambda();
​
    }
}
​
//1.定义一个函数式接口，只有一个方法
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
​
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

总结：

package com.HuoLong.lambda;
​
public class Test001 {
    //2.静态内部类
    static class myOne1 implements My{
        @Override
        public void My01() {
            System.out.println("bbb");
        }
    }
    public static void main(String[] args) {
        My my = new MyOne();//多态，父类的引用指向子类的对象
        my.My01();//1.
        my=new myOne1();
        my.My01();//2.
​
​
        //3.局部内部类  内部类的new、引用 要写在它的下面
        class myOne02 implements My{
            @Override
            public void My01() {
                System.out.println("ddd");
            }
        }
        my=new myOne02();
        my.My01();//3.
​
        //匿名内部类  内部类的new、引用 要写在它的下面
        //没有类的名字，右边必须借助接口或父类
        my= new My() {
            @Override
            public void My01() {
                System.out.println("ccc");
            }
        };
        my.My01();
​
    }
​
}
//接口
interface My{
    void My01();
​
}
//1.实现接口
class MyOne implements My{
​
    @Override
    public void My01() {
        System.out.println("aaa");
    }
}

package com.HuoLong.lambda;
​
public class Test001 {
    //2.静态内部类
    static class myOne1 implements My{
        @Override
        public void My01() {
            System.out.println("bbb");
        }
    }
    public static void main(String[] args) {
        My my = new MyOne();//多态，父类的引用指向子类的对象
        my.My01();//1.
        my=new myOne1();
        my.My01();//2.
​
​
        //3.局部内部类  内部类的new、引用 要写在它的下面
        class myOne02 implements My{
            @Override
            public void My01() {
                System.out.println("ddd");
            }
        }
        my=new myOne02();
        my.My01();//3.
​
        //匿名内部类  内部类的new、引用 要写在它的下面
        //没有类的名字，右边必须借助接口或父类
        my= new My() {
            @Override
            public void My01() {
                System.out.println("ccc");
            }
        };
        my.My01();
​
    }
​
}
//接口
interface My{
    void My01();
​
}
//1.实现接口
class MyOne implements My{
​
    @Override
    public void My01() {
        System.out.println("aaa");
    }
}

 

搜索

复制