JAVA語言是使用率比較高的一種程式語言，有一些隨著JDK升級，後來增加的重要的特性需要記錄下來，便於學習和使用。

1、可變引數使用

對於一個方法中的引數，一般情況下是固定的格式，但是JDK1.5之後，JAVA語言引入了可變引數，基本語法就是：（型別 ... 引數），如下面程式碼所示：

/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: ChangedParameter
 * Author:   gysh
 * Date:     2018/11/19 15:12
 * Description: 可變引數的演示
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改時間           版本號              描述
 */

/**
 * 〈一句話功能簡述〉<br> 
 * 〈可變引數的演示〉
 *
 * @author gysh
 * @create 2018/11/19
 * @since 1.0.0
 */
public class ChangedParameter {
    public static void main(String[] args) {
      test(1,2,3,4,5,6,7);
      test(3,4,5,6,7);
    }

    public static  void test(int ... data){
        int sum = 0;
       /* for (int i = 0; i <data.length ; i++) {
            sum += data[i];
        }*/
        for (int i : data
        ){
            sum += i;
        }
        
        System.out.println(sum);
    }
}
 

2、foreach用法

foreach的語法結構如下：

for(型別 變數：陣列或集合){

}如下 程式碼：

    public static  void test(int ... data){
        int sum = 0;
       /* for (int i = 0; i <data.length ; i++) {
            sum += data[i];
        }*/
        for (int i : data
        ){
            sum += i;
        }

        System.out.println(sum);
    }
 

3、靜態匯入（方法）

一般情況下我們對於靜態方法的呼叫都是通過類名.方法的形式去操作，IDE會自動匯入對就的jar包，但是，在jdk 1.5之後，可以直接匯入方法，並在程式中直接使用，建議這種方法最好不用（程式可讀性變差），如下程式碼：

/**
 * Copyright (C), 2015-2018, XXX有限公司
 * FileName: StaticTest
 * Author:   gysh
 * Date:     2018/11/19 15:59
 * Description: 靜態匯入方法的使用
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改時間           版本號              描述
 */

/**
 * 〈一句話功能簡述〉<br> 
 * 〈靜態匯入方法的使用〉
 *
 * @author gysh
 * @create 2018/11/19
 * @since 1.0.0
 */
import  static java.lang.Math.*;
public class StaticTest {
   /* public static void main(String[] args) {
//        System.out.println(Math.subtractExact(20,18));
        sy
    }*/

    public static void main(String[] args) {
        System.out.println(subtractExact(20,18));

    }
}
 

4、泛型技術使用

在jdk 1.5之後開始增加了泛型技術，泛型技術的核心意義在於：類在定義的時候，通過一個識別符號，此識別符號可以標記類中屬性或者方法引數的資料型別，在使用的時候，系統能夠動態的設定型別，如下 程式碼：

public class XYPoint <T>{//T也可以換成其它標記都可以
    private T x;
    private T y;

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}

如何使用，程式碼如下：

public class XYPointTest {
    public static void main(String[] args) {
        XYPoint<String> xy = new XYPoint();
        xy.setX("wq");
        xy.setY("wq");
        System.out.println(xy.getX()+xy.getY());
    }
}

注意：

1、泛型最好設定型別，如果不設定的情況下，系統會預設使用Object類，同時在編譯的時候會有警告

2、泛型中的型別設定都要是類，基本資料型別不可以，對於整形能用：Integer等

4.1、泛型萬用字元：？，對於？萬用字元基礎之上還有兩個子萬用字元：

•     ？extends 類：設定泛型上限，可以在宣告上和方法引數上使用，比如：？extends Number:意味著萬用字元代表Number類以及它的子類：Integer、Long等

• ? super 類：設定泛型的下限，方法引數上使用，比如:? Super:String :意味著只能設定String以及它的父類：Object

4.2、介面泛型的實用

對於JAVA的介面中的方法都是Public許可權！！

如果介面是泛型介面，對於子類來實現介面有兩種形式：

1、在子類中直接使用泛型

2、在子類中不設定泛型，而是在介面中明確一個型別

對於上面兩種實現，請看下面程式碼：

import java.awt.image.ImageConsumer;

/**
 * 〈一句話功能簡述〉<br> 
 * 〈泛型介面使用測試〉
 *
 * @author gysh
 * @create 2018/11/19
 * @since 1.0.0
 */
interface IMessage<T>{
    public void print(T s);

}

/**
 * 對於介面泛型子類的實現形式：在子類中定義泛型的型別（這個是經常使用的）
 */
class Message implements IMessage<String>{
    @Override
    public void print(String s) {
        System.out.println(s);
    }
}

/**
 * 對於介面泛型子類的實現形式：在子類中直接設定泛型
 * @param <T>
 */
class MessageImpl<T> implements IMessage<T>{
    @Override
    public void print(T s) {
        System.out.println(s.toString());
    }
}
public class GenericTypeTest {
    public static void main(String[] args) {
        IMessage im = new Message();
        im.print("你好！！");
        IMessage im2 = new MessageImpl();
        im2.print("wq");
    }
}

4.3 泛型方法使用

泛型方法就是在方法的返回值和引數上面增加泛型，這樣的方法就是泛型方法，如下程式碼：

/**
 * 〈一句話功能簡述〉<br> 
 * 〈泛型方法使用測試〉
 *
 * @author gysh
 * @create 2018/11/19
 * @since 1.0.0
 */
public class GenericMethodTest {
    public static void main(String[] args) {
    print("你好！中國");
    }
    public static <T> T print(T m){
        System.out.println(m);
        return m;
    }
}

泛型技術總結：

1、泛型技術主要解決的是向下轉型所帶來的隱患，其核心就是在宣告類或介面的時候，不設定引數或者屬性的型別，而是動態的執行型別。

2、“？”可以接受任意型別的泛型，只能夠取出，不能進行修改。

5、Annotation使用

Annotation技術，是JAVA在JDK1.5之後，變化比較大的一項，就是利用註解的形式來實現程式的不同功能的實現。並且支援自定義Annotation的開發，還提供了三個常用的註解：@Override、@Deprecated、@SuppressWarnings。

• @Overide是方法覆寫，就是繼承或者實現類和介面的時候，一般會重寫對應的方法。
• @Deprecated 是宣告過期操作，宣告對應的方法是過期的
• @SuppressWarnings是用來壓制警告

6、介面方法的增強

對於JAVA 1.8之後，在介面中增加了普通方法，對於原先介面中只有全域性變數和抽象方法的定義進行了調整，不過我們會一直認為所謂的介面只有全域性變數和抽象方法，至於在介面中增加普通方法和靜態方法的目的是方便在於介面被成千上萬的類實現之後，增加一個方法，如下面程式碼所示：

interface IMessage1{
    public void print();
    default void  fun(){
        System.out.println("增加的普通方法！");
    }
    static void get(){
        System.out.println("介面中增加靜態方法！！");
    }
}
class MessageImpl1 implements IMessage1{

    public void print() {
        System.out.println("正常方法！");
    }
}
public class InterfaceTest {
    public static void main(String[] args) {
        IMessage1 im = new MessageImpl1();
        im.print();
        im.fun();
        IMessage1.get();
    }
}

7、Lamda表示式

lamda表示式其實就是代替JAVA中的匿名類的操作（匿名類是在抽象類和介面上發展起來的），比較簡單語法如下：

• （引數）->單行語句；
• （引數）->{單行語句}；
• （引數）->表示式

interface IMessage2{
    public void print();
}

public class LamdaClass {
    public static void main(String[] args) {
        //內部匿名類的使用
     printTest(new IMessage2() {
         @Override
         public void print() {
             System.out.println("內部匿名類的使用！！");
         }
     });
     //Lamda表示式的使用
     printTest(()-> System.out.println("Lamda表示式的使用！！"));
    }
    public static void printTest(IMessage2 message){
        message.print();
    }
}

Lamda表達是用來避免匿名內部類中過多無用的東西。

8、方法引用

在JAVA 8之中，方法一共有四種形式：

• 引用靜態方法：類名稱 :: static 方法名稱；
• 引用某個物件的方法：例項化物件：：普通方法；
• 引用特定型別的方法：特定類：：普通方法；
• 引用構造方法：類名稱：：new.

引用靜態方法，用String中的valueOf方法：public static String valueOf(int x);通過引用實現如下：

interface IMessage4<P,R>{
    public R zhuanHuan(P p);
}
public class QuotoTest {
    public static void main(String[] args) {
        IMessage4<Integer,String> msg = String ::valueOf;
        //msg.zhuanHuan(2000);
        System.out.println(msg.zhuanHuan(30000));
    }
}

引用某個物件的方法：

interface IMessage4<R>{
    public R upper();
}
public class QuotoTest {
    public static void main(String[] args) {
        IMessage4<String> msg = "hello" ::toUpperCase;
        //msg.zhuanHuan(2000);
        System.out.println(msg.upper());
    }
}

說明：對於引用方法中的介面必須定義 一個方法，如果有兩個方法就會報錯，為了防止有兩個方法，可以直接加上一個註解：

@FunctionalInterface 這個表明是一個函式式的介面，只能有一個方法。

特定型別的引用：採用String的compareTo方法，如下程式碼：

@FunctionalInterface
interface IMessage4<P>{
    public int compare(P p1,P p2);
}
public class QuotoTest {
    public static void main(String[] args) {
        IMessage4<String> msg = String ::compareTo;
        //msg.zhuanHuan(2000);
        System.out.println(msg.compare("A","B"));
    }
}

構造方法引用：如下程式碼：

interface IMessage4<C>{
    public C create(String st1,double d);
}
class Book{
    private String titel;
    private double price;
    public Book(String titel,double price){
    this.titel =titel;
    this.price = price;
    }

    public String getTitel() {
        return titel;
    }

    public void setTitel(String titel) {
        this.titel = titel;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "本書的書名是："+this.titel+"-----本書的價格是："+this.price;
    }
}
public class QuotoTest {
    public static void main(String[] args) {
        IMessage4<Book> msg = Book :: new;

        System.out.println(msg.create("A",23.2));
    }
}

對於上面的方法引用都是JDK 1.8版本之上才能使用，一般情況下我們看別人的程式碼的時候只要能看的懂，不需要刻意去使用它。

9、內建函式式介面

JDK 1.8之後，產生了內建函式式介面，一共有四種介面，分別是：

功能性介面（Function）：public interface Function<T,R>{public R apply(T t );}程式碼如下：

消費性介面（Consumer）： public interface Consumer<T> {public void accept(T t);}

供給性介面（Supplier）：public interface Supplier<T> {public T get();}

斷言型介面：就是判斷的使用：

總結說明：這些介面都包含所有可能出現的方法引用。