java1.8的几大新特性（一）

一、接口的默认方法与静态方法，也就是接口中可以有实现方法

 public class Test {
     public static void main(String[] args) {
         Formula a=new For();
         a.calculate(1);
         System.out.println(a.sqrt(8));

     }
     interface Formula {
         double calculate(int a);
         default double sqrt(int a) {//这个方法可以在实现类重写，或者直接使用
             return Math.sqrt(a);
         }
     }
     static class For implements Formula{
         @Override
         public double calculate(int a) {
             return 0;
         }

         @Override
         public double sqrt(int a) {
             return 0;
         }
     }
 }

 package com.ming.jdk18;

 /**
  *
  * @author mingge
  * jdk1.8接口支持静态方法与默认方法
  *
  */
 public interface TestInterface {

     //这个是默认方法
     default String get(String aa,String bb){
         System.out.println("我是jdk1.8默认实现方法...");
         return "";
     }

     String aa="2222";

     //这个是静态方法
     static void staticmethod(){System.out.println("我是静态方法"+aa);}
 }

 package com.ming.jdk18;

 public class Main {

     public static void main(String[] args) {
         TestInterface.staticmethod();
     }

 }

以前的版本定义接口是不能有实现机制的，现在这样用了一个default关键字后，就可以实现，然后子类可以重写，也可以直接使用了。好处多多，感觉有点抽象类了...越来越灵活了。加入静态方法后，你以后的工具类就可以参考接口来设计啦.这是一个优点啦.

二、Lambda 表达式

 public class Test {
     public static void main(String[] args) {
         List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
         Collections.sort(names, new Comparator<String>() {//java以前老版本的写法
             @Override
             public int compare(String a, String b) {
                 return b.compareTo(a);
             }
         });
         for(String name:names){
             System.out.println(name);
         }
     }

 }

 只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。
 在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：
 复制代码 代码如下:

 5 Collections.sort(names, (String a, String b) -> {
 6     return b.compareTo(a);
 7 });

 看到了吧，代码变得更段且更具有可读性，但是实际上还可以写得更短：
 复制代码 代码如下:

 Collections.sort(names, (String a, String b) -> b.compareTo(a));

 对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：
 复制代码 代码如下:

 Collections.sort(names, (a, b) -> b.compareTo(a));

 Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还能作出什么更方便的东西来：

lambda表达式的使用简化了代码。

三、函数式接口与静态导入

Lambda表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。

因为默认方法不算抽象方法，所以你也可以给你的函数式接口添加默认方法。

我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

 public class Test {
     public static void main(String[] args) {
         Converter<String, Integer> a = (from) -> Integer.valueOf(from);

         //Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用
         Converter<String, Integer> converter = Integer::valueOf;//这个是静态方式导入 

         Integer m=a.convert("123");
         System.out.println(m);
         test test=mmm -> "aaaa";//mmm代表你要传入的参数
         String testResult=test.aa("");//aa代表你要传入的方法
         System.out.println(testResult);
     }

     @FunctionalInterface
     interface Converter<F, T> {
         T convert(F from);
     }

     interface test{
         String aa(String mmm);
     }

     //使用函数式接口时，接口的定义只能有一个，@FunctionalInterface注解可有可无
 }

四、Lambda 作用域

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

五、访问局部变量

 public class Test {
     public static void main(String[] args) {
         final int num = 1;
         Converter<Integer, String> stringConverter =
                 (from) -> String.valueOf(from + num);
         String str=stringConverter.convert(2);
         System.out.println(str);//输出3
         //final关键字可以去掉，但是默认是存在的，所以，对num变量不能再次赋值修改
     }

     @FunctionalInterface
     interface Converter<F, T> {
         T convert(F from);
     }

 }

六、访问对象字段与静态变量

 public class Test {
     public static void main(String[] args) {
         Lambda4 lambda4=new Lambda4();
         lambda4.testScopes();
     }

     @FunctionalInterface
     interface Converter<F, T> {
         T convert(F from);
     }

     static class Lambda4 {
         static int outerStaticNum=0;
         int outerNum=0;
         void testScopes() {
             Converter<Integer, String> stringConverter1 = (from) -> {
                 outerNum = 23;
                 return String.valueOf(outerNum);
             };
             String a=stringConverter1.convert(outerNum);
             System.out.println(a);//输出23
             Converter<Integer, String> stringConverter2 = (from) -> {
                 outerStaticNum = 72;
                 return String.valueOf(outerStaticNum);
             };

         }
     }

     //这里的意思是outerStaticNum与outerNum两个参数可以多次赋值

 }