JDk 5 之后的新特性

JDK 5 之后的新特性

Jdk5以后的新特性:

增强for,静态导入,可变参数,泛型......

（1）增强for循环

   格式：
           for(数据大类型变量名 : 数组或者集合对象名){
                   输出变量即可!
            }

增强for的出现时替代迭代器的,所以在遍历集合或者遍历数组就可以使用增强for去完成

增强for循环的弊端:如果集合的对象是null,如果再次对集合操作,就会出现异常
       对集合进行判断,非空判断解决

public class Demo_01 {
public static void main(String[] args) {
        //创建一个ArrayList集合
    ArrayList<String> as=new ArrayList<String>();
    //添加元素
    as.add("aaa1");
    as.add("aaa2");
    as.add("aaa3");
    as.add("aaa1");
    //使用增强for循环遍历
    for(String s : as) {
        System.out.println(s);
    }
    //定义一个数组
    int[] s= {12,34,56,74,87,53};
    //用增强for循环遍历
    for(int x:s) {
        System.out.println(x);
    }
    
}
}
显示：
aaa1
aaa2
aaa3
aaa1
12
34
56
74
87
53

（2）可变参数:当一个方法的参数个数不确定的时候,要使用可变参数

格式:
修饰符返回值类型方法名(数据类型...变量名){ //数据类型后的三个点就是可变参数的表现形式
方法体
}
例如：

//求数据的和
ppublic class Demo_02 {
public static void main(String[] args) {
    int a=9;
    int b=4;
    int c=5;
    int d=7;
    int e=6;
    int f=23;
    int sum=plus(a,b,c,d,e,f);
    System.out.println(sum);
}
public static int plus(int x,int y) {
    int sum=0;
    sum=x+y;
    return sum;
}
public static int plus(int x,int y,int z) {
    int sum=0;
    sum=x+y+z;
    return sum;
}
public static int plus(int x,int y,int z,int t) {
    int sum=0;
    sum=x+y+z+t;
    return sum;
}

//当我们的参数不确定的情况下,就可以使用jdk5一个特性:可变参数，参数数据类型需相同
public static int plus(int...a) {
    //求和:将a是多个参数的,看成数组
    
    //先定义最终结果变量
    int sum = 0 ;
    //增强for遍历可变参数a
    for(int n :a) {
    sum += n ;
    }
    return sum;
}
}
结果：54

（3）静态导入

特点:
1)前提是该方法必须是静态的
2)导入到的一个方法的级别
静态导入的格式:
import static 包名.类名.方法名;
用Math类来举例

import static java.lang.Math; //导入到包
  Sysotem.out.println(Math.abs(100));

import static java.lang.Math.abs;//导入到方法的级别
  Sysotem.out.println(abs(100));

System.out.println(java.lang.Math.abs(100));//可以直接导入 ，给方法加上前缀

注意：本身当前的某个类中的方法名和需要被静态导入的方法名一样,必须加上前

（4）泛型

当ArrayList集合中存储了两种类型的元素分别String和Integer类型,在遍历的时候,使用的是String接收的,对于Integer类型就出现了异常!
数组直接定义了存储的类型,防止出现其他类型的元素,集合能不能也像数组一样,直接规定我们集合的存储类型,针对这种情况就提供了新技术:泛型
     泛型只能是引用类型
泛型的好处:
      1)将运行时期异常提前到了编译时期
       2)优化了设计,解决了黄色警告线问题
        3)避免了强制类型转换
           4)泛型的引出可以提供程序的安全性!

public class GenericDemo {

    
    public static void main(String[] args) {
        
        
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>() ;
        
        //添加元素
        array.add("hello") ;
        array.add("world") ;
        array.add("java") ;
        
        //遍历
        //获取迭代器
        Iterator<String> it = array.iterator() ;
        while(it.hasNext()) {
            String s = it.next() ;//使用泛型此处不需要强制类型转换
            System.out.println(s);
        }
    }
}

*泛型高级(通配符)
*<?> :代表任意类型Object类型,或者任意的Java类
*<? extends E>:向下限定,E的子类或者E这个类型
*<? super E>:向上限定,E及其他的父类

 //<?>  :代表任意类型Object类型,或者任意的Java类
        Collection<?> c4 = new ArrayList<Object>() ;
        Collection<?> c5 = new ArrayList<Animal>() ;
        Collection<?> c6 = new ArrayList<Dog>() ;
        Collection<?> c7= new ArrayList<Cat>() ;
        
        <? extends E>:向下限定,E的子类或者E这个类型
        Collection<? extends Object> c8 = new ArrayList<Object>() ;
        Collection<? extends Object> c9 = new ArrayList<Animal>() ;
        Collection<? extends Object> c10 = new ArrayList<Cat>() ;
        Collection<? extends Aninal> c11 = new ArrayList<Object>() ;//报错
        
        <? super E>:向上限定,E及其他的父类
        Collection<? super Animal> c12 = new ArrayList<Cat>() ;//报错
        Collection<? super Animal> c13 = new ArrayList<Animal>() ;
        Collection<? super Animal> c14 = new ArrayList<Object>() ;