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以前老版本的寫法  5             @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兩個參數可以多次賦值
    
}