【Java1.8】实现类、匿名类、内部类、匿名内部类、Lambda表达式以及优化Lambda表达式比较

  梳理一下实现类、匿名类、内部类、匿名内部类、Lambda表达式以及优化Lambda表达式的关系,仅针对初学者。
  自定义一个接口MyFunctionInterface,其中有且仅有一个抽象方法(接口中可以有其他非抽象方法内容),代码实现为:

1
2
3
4
5
6
7
8
9
/*
函数式接口:有且只有一个抽象方法的接口,称之为函数式接口;
当然接口中可以包含其他的方法(默认,静态,私有)。
*/
public interface MyFunctionInterface {

public abstract void method();

}
  1. 实现类(创建实现类对象)
      实现接口MyFunctionInterface,重写其中的抽象方法;新建一个Java文件,实现类代码为:
    1
    2
    3
    4
    5
    6
    7
    8
    public class MyFunctionInterfaceImpl implements MyFunctionInterface {

    @Override
    public void method() {
    System.out.println("测试成功");
    }

    }

  新建一个测试类,代码为:

1
2
3
4
5
6
7
8
public class Demo {
public static void main(String[] args) {

MyFunctionInterface mi = new MyFunctionInterfaceImpl();//多态
mi.method();

}
}
  1. 匿名类(创建匿名实现类对象)

    1
    2
    3
    4
    5
    6
    7
    public class Demo {
    public static void main(String[] args) {

    new MyFunctionInterfaceImpl().method();

    }
    }
  2. 内部类(不需要创建实现类对象)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class Demo {
    public static void main(String[] args) {

    MyFunctionInterface mi = new MyFunctionInterface() {
    @Override
    public void method() {
    System.out.println("内部类测试成功");
    }
    };
    mi.method();

    }
    }
  3. 匿名内部类(不需要创建实现类对象)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Demo {
    public static void main(String[] args) {

    new MyFunctionInterface() {
    @Override
    public void method() {
    System.out.println("匿名内部类测试成功");
    }
    }.method();

    }
    }
  4. Lambda表达式
      因为接口MyFunctionInterface中有且仅有一个抽象方法,所以是函数式接口,可以使用Lambda表达式,代码实现:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Demo {
    public static void main(String[] args) {

    MyFunctionInterface mi = () -> {
    System.out.println("Lambda表达式测试成功");
    };
    mi.method();

    }
    }
  5. 优化Lambda表达式

    1
    2
    3
    4
    5
    6
    7
    8
    public class Demo {
    public static void main(String[] args) {

    MyFunctionInterface mi = () -> System.out.println("优化Lambda表达式测试成功");
    mi.method();

    }
    }

  实际上,Lambda表达式常用作方法的参数或方法的返回值。
当Lambda表达式作为方法的形参:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Demo {

public static void show(MyFunctionInterface myInter) {
myInter.method();
}

public static void main(String[] args) {
/*
//先使用匿名内部类热热身
show(new MyFunctionInterface() {
@Override
public void method() {
System.out.println("匿名内部类测试成功");
}
});//show方法执行myInter.method()之前,method方法已经重写,所以执行成功
*/
//Lambda表达式
show(() -> {
System.out.println("Lambda表达式测试成功");
});
//优化的Lambda表达式
show(()->System.out.println("优化的Lambda表达式测试成功"));
}

}

当Lambda表达式作为方法的返回值(这里使用接口Comparator< String >举例):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Demo {
//定义一个方法,方法的返回值类型使用函数式接口Comparator
public static Comparator<String> getComparator() {//接口Comparator<>只有一个抽象方法,所以可以使用Lambda表达式
/*
//先用匿名内部类热热身
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length()-o1.length();//按字符串降序排序
}
};
*/
//方法的返回值类型是一个函数式接口,所有我们可以返回一个Lambda表达式(优化后的)
return (o1, o2) -> o2.length() - o1.length();
}

public static void main(String[] args) {
String[] arr = {"cc","bbb","aaaa"};//首先按字符个数、再按字母进行降序
Arrays.sort(arr,getComparator());//sort(T[] a, Comparator<? super T> c) 根据指定的比较器引发的顺序对指定的对象数组进行排序。
System.out.println(Arrays.toString(arr));//打印结果:[aaaa, bbb, cc]
}
}
————————— 本文结束 感谢您的阅读 —————————
谢谢你请我喝咖啡ლↂ‿‿ↂლ(支付宝扫一扫即可领红包, 消费时可抵现! 你省钱, 我赚钱, 多谢支持~)