一文学会JDK5的新特性

泛型，枚举，静态导入，自动拆装箱，增强for，可变参数

泛型

泛型的简介：
泛型的主要作用是实现Java类型安全，泛型可以让编译器知道对象的限定类型是什么。消除了强制类型转换 使得代码可读性好，减少了很多出错的机会

泛型擦除现象：首先泛型只是出现在源代码阶段，当编译之后泛型就不存在了。

泛型一般使用在集合上
比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本身的类型，只能是object类型。

这个时候，比如想要对这个之进行数据类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决

在集合中使用泛型：
常用集合：list，set，map
泛型的语法：集合<String>比如Lish<String>
在泛型里面写一个对象，不能写基本类型的数据类型，比如int，char。
要写基本数据类型的包装类

	byte -- Byte
	short -- Short
	int -- Integer
	long -- Long
	float -- Float
	double -- Double
	char -- Character
	boolean --Boolean

在list集合上使用泛型

	list的三种实现类：ArrayList,linkedList,Vector

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("ccc");
        // 遍历集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

泛型使用在方法上：
定义一个数组，实现指定位置上数组元素交换（要可以兼容个中的类型比如integer，String)。

一般在方法的逻辑相同，只是数据类型不同，这个时候就要使用泛型方法。

使用泛型方法时，需要定义一个类型，使用大写字母表示。可以使用任意大写字母表示，不过一般遵循以下原则：
T：指一般的任何类。E：元素 Element 的意思，或者 Exception 异常的意思。K：键，Key 的意思。V：值，Value 的意思，通常与 K 一起配合使用。

public class Demo {
    public static void main(String[] args) {
    // 由于泛型需要使用写的是基本类型的包装类，所以使用Integer
        Integer[] arr = {10,34,5,6,77,8,3,323,2};
        String[] arr1 = {"lalal","ala","shaonian","zheng","shao"};
        test(arr);
    }
    // 实现对任意类型的数组进行顺序颠倒

    public static <T> void test(T[] arr){
        for (int i = 0; i < arr.length/2; i++) {
            T temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        for (T t : arr) {
            System.out.println(t);
        }
    }
}

泛型在类中使用：

• 在一个类上定义一个类型，这个类型可以在类里面使用
• 格式：

public class Demo<T>{
// 在类里面就可以直接使用T类型
	T a;
	public void test(T b){
	
	}
}

特殊：静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定，可以将泛型定义在静态方法上面。

public static <T> void test(T cc){
}

枚举

枚举的概念：

• 需要在一定的范围内取值，这个值只能时这个范围内中的任意一个。
• 现实中的案例：比如红绿灯，只有三种颜色，但是每次只能出现一种颜色。

枚举的使用：

• 使用关键字：enum。

enum Demo{
	RED,YELLOW,GREEN;
}

• 枚举的构造方法也是私有的
• 在枚举类里面有构造方法
  构造方法里面有参数，需要在每个实例上面都写参数。
• 在枚举类里面有抽象方法
  在枚举的每个实例里面都重写这个抽象方法。

枚举的api中常用的方法：

1. name():返回枚举的名称
2. ordinal():枚举的下标，下标从0开始
3. valueOf(Class<T> enumType,String name):得到枚举的对象
4. valueof(String name):转换枚举对象
5. values():获得所有枚举对象数组

静态导入

可以在代码里面直接使用静态导入方式，导入静态或者常量
注意：

1. 方法必须是静态的
2. 如果有多个同名的静态方法，容易不知道使用谁.这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不会使用。

// 格式
import static **.**.**
// 这个是输出语句的方法
import static java.lang.System.out;
public class Demo{
	public static void mian(String[] args){
	// 静态导入的简单实用
	out.println("Hello World");
	}
}

自动拆装箱

• 装箱
  把基本数据类型转换成包装类
• 拆箱
  把包装类转换成基本数据类型

// 自动装箱
Integer i = 10;
// 自动拆箱
int m = i;

在jdk5之前怎么实现拆装箱：

public void test(){
	// 装箱
	Inerger i = new Integer(11);
	// 拆箱
	int a = i.intValue();
}

Foreach语法（增强for）

JDK5引入的一种新的简洁的for语法用于数组和容器，出现的目的是为了：替代迭代器。
语法：

for(String s : list){
	System.out.println(s);
]

使用场景：数组，实现Iterable接口的集合，可以使用增强for循环。
增强for的底层就是迭代器。

可变参数

可变参数的应用场景：

1. 实现两个数相加，三个数相加，四个数相加。
2. 实现多个方法，且方法里面的逻辑基本相同，不同的只是传递的参数的个数，可以使用可变参数

注意：

1. 调用可变参数的方法时，编译器将自动创建一个数组保存传递给方法的可变参数，因此，程序员可以在方法体中以数组的形式访问可变参数。
2. 可变参数需要写在方法的参数列表中，不能单独定义。
3. 在方法的参数列表中只能有一个可变参数
4. 可变参数必须放到最后面
   public static void add(int a,int…num){}

// 简单的使用，传递任意数量获得相加之和
public static void main(String[] args) {
       add(1,2,3,4,45,23);
    }
    public static void add(int...num){
        int sum = 0;
        for(int i = 0;i < num.length;i++){
            sum += num[i];
        }
        System.out.println(sum);
    }