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

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

/*
    函数式接口：有且只有一个抽象方法的接口，称之为函数式接口；
    当然接口中可以包含其他的方法（默认，静态，私有）。
 */
public interface MyFunctionInterface {

    public abstract void method();
    
}

1. 实现类（创建实现类对象）
     实现接口MyFunctionInterface，重写其中的抽象方法；新建一个Java文件，实现类代码为：

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

  新建一个测试类，代码为：

public class Demo {
    public static void main(String[] args) {
    
        MyFunctionInterface mi = new MyFunctionInterfaceImpl();//多态
        mi.method();
        
    }
}

2. 匿名类（创建匿名实现类对象）

   public class Demo {
       public static void main(String[] args) {
       
           new MyFunctionInterfaceImpl().method();
           
       }
   }

3. 内部类（不需要创建实现类对象）

   public class Demo {
       public static void main(String[] args) {
       
           MyFunctionInterface mi = new MyFunctionInterface() {
               @Override
               public void method() {
                   System.out.println("内部类测试成功");
               }
           };
           mi.method();
           
       }
   }

4. 匿名内部类（不需要创建实现类对象）

   public class Demo {
       public static void main(String[] args) {
       
           new MyFunctionInterface() {
               @Override
               public void method() {
                   System.out.println("匿名内部类测试成功");
               }
           }.method();
           
       }
   }

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

   public class Demo {
       public static void main(String[] args) {
       
           MyFunctionInterface mi = () -> {
               System.out.println("Lambda表达式测试成功");
           };
           mi.method();
           
       }
   }

6. 优化Lambda表达式

   public class Demo {
       public static void main(String[] args) {
       
           MyFunctionInterface mi = () -> System.out.println("优化Lambda表达式测试成功");
           mi.method();
           
       }
   }

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

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 >举例）：

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]
    }
}