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();}

断言型接口：就是判断的使用：

总结说明：这些接口都包含所有可能出现的方法引用。

JAVA高级语言随着JDK升级新增特性