JDK1.5 新特性

引言：本文主要介绍了自动拆装箱，增强for,静态导入,可变参数；

1. 自动拆装箱

JDK1.5后简化了定义方式提供自动装箱、拆箱，使得基本类型和包装类型自动转换，简化使用包装类的编程过程。

• 自动装箱：将基本类型赋值包装类型，调用valueOf（int i）(int---->Integer)

• 自动拆箱：将包装类型值直接赋值给基本类型调用intValue()（Integer--->int）

public static void main(String[] args) {
   
        //基本类型
        int i1 = 100;
        //包装类型
        Integer i2 = new Integer("200");
        Integer i3 = Integer.valueOf("300");

        //JDK1.5之后
        //自动装箱
        Integer i4 = 400;//基本类型给了对象

        //自动拆箱
        //int i5 = i4.intValue();简化为
        int i5 = i4;

        //使用基本类型没有方法只是属性，使用包装类型可以在调用属性的同时调用对应的方法
        Student s = new Student();
        int ii = s.age.sum(1, 2);//调用求和方法
        System.out.println(ii);
    }
}
class Student{
   
    String name;//包装类型
    Integer age;
    Double id;
}

注：使用基本类型没有方法只是属性，使用包装类型可以在调用属性的同时调用对应的方法；（代

码见上）

2. 增强For

增强for循环可以遍历集合,也可以遍历数组，但是以遍历嵌套集合居多；使用增强For的目的是为了简便代码的书写；

格式：

for(数据类型 变量名 ： 集合对象/数组对象){

        输出变量名；

}

在集合中使用增强For的注意事项：使用增强For遍历集合，前提是集合不能为空；

• 空指针异常的解决方案：对对象进行非空判断,不为空再去进行后续操作；
• NullPointerException:空指针异常异常

2.1 增强For遍历数组

public static void main(String[] args) {
   
    //定义数组int类型的数组
    int[] arr = {
   57,69,24,13,17} ; 

    //普通for循环
    for(int x = 0 ; x < arr.length ; x ++) {
   
        System.out.println(arr[x]);
    }
    System.out.println("-------------------------");
    //增强for遍历
    for(int a : arr) {
   
        System.out.println(a);
    }
}

2.2 增强For遍历集合

public static void main(String[] args) {
   
    //创建List集合对象
    List<String > array = new ArrayList<String>() ;

    //添加元素
    array.add("kaka") ;
    array.add("hello") ;
    array.add("java") ;

    //将集合对象置为null
    array = null ;
    if(array!=null) {
   
        for(String s : array) {
    
            System.out.println(s);
        }
    }
}

2.3 增强For遍历案例

需求:有5个学生,都有姓名和年龄,现需要将5个学生存储到集合中,并用增强For遍历5个学生信息

1)定义一个学生类

2)创建集合对象 Collection

3)创建5个学生

5)将5个学生添加到集合中

6)使用增强For遍历集合

/*
 * 学生类
 */
public class Student {
   
    private String name;
    private int age;
    public Student(String name, int age) {
   
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
   
        super();
        // TODO Auto-generated constructor stub
    }
    public String getName() {
   
        return name;
    }
    public void setName(String name) {
   
        this.name = name;
    }
    public int getAge() {
   
        return age;
    }
    public void setAge(int age) {
   
        this.age = age;
    }
    @Override
    public String toString() {
   
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

public static void main(String[] args) {
   
    //ArrayList集合对象
    ArrayList<Student> array = new ArrayList<Student>() ;

    //创建学生对象
    Student s1 = new Student("高圆圆", 29) ;
    Student s2 = new Student("高圆圆", 28) ;
    Student s3 = new Student("赵又廷", 30) ;
    Student s4 = new Student("邓超", 25) ;

    //给集合中添加
    array.add(s1) ;
    array.add(s2) ;
    array.add(s3) ;
    array.add(s4) ;

    //增强for循环遍历 (遍历集合:就使用foreach:增强for)
    for (Student student : array) {
   
        System.out.println(student.getName()+"---"+student.getAge());
    }
}

3. 静态导入

格式：

• import static 包名….类名.方法名;
  • 可以直接导入到方法的级别；

注意事项：

• 方法必须是静态
• 本身如果一个类中有一些成员方法,它静态导入的方法名一样,此时不能直接使用，必须加前缀：包名；

import static java.lang.Math.abs; //导入到方法的级别
import static java.lang.Math.pow; 
import static java.lang.Math.max; 

public class StaticImportDemo {
   
    public static void main(String[] args) {
   
        //abs(double/..):求出这个数据的绝对值
        System.out.println(Math.abs(-100));//100

        //public static int max(int a,int b)//获取最大值
        System.out.println(Math.max(10, 5));//10
        //public static int min(int a,int b):获取最小值
        System.out.println(Math.max(10, 5));//5
        //public static double pow(double a, double b):a的b次幂
        System.out.println(Math.pow(2.0, 3.0));8.0

        //某个成员方法名字和静态导入的方法名一样,还需要使用静态导入的方法名:加上方法名的前缀:包名
        System.out.println(java.lang.Math.abs(-100));//100
        System.out.println(pow(2.0,2.0));//4.0
        System.out.println(java.lang.Math.max(20,60));//60
    }
    //成员方法
    public static void abs() {
   }
}

4. 可变参数

当一个方法形式参数不知道有多少个使用可变参数

格式：

• 权限修饰符 返回值类型 方法名(数据类型...变量名) {}

注意事项：

• 这里的变量其实是一个数组
• 如果一个方法有可变参数并且有多个参数，那么可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数；
• 变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的。可变参数可以兼容数组，反之则不成立。
• 可变参的参数类型可以为泛型

可变参数使用最多的地方:反射

• public Method getDeclaredMethod(String name, Class<?>... parameterTypes):获取当前字节码文件对象中的指定的成员方法
• public Constructor getConstructor(Class<?>... parameterTypes)获取当前字节码文件对象所有的公共访问的构造方法

public static void main(String[] args) {
   

    //求两个数据之和
    int a = 10 ;
    int b = 20 ;

    int result1 = sum(a,b) ;
    System.out.println(result1);//30
    int c = 30 ;
    int result2 = sum(a,b,c) ;
    System.out.println(result2);
    int d = 40 ;
    int result3 = sum(a,b,c,d) ;
    System.out.println(result3);

    //sum方法定义的时候使用可变参数
    int result4 = sum(10,20,30,40,50) ;
    System.out.println(result4);

}

// 定义一个方法,参数不知道有多少个
public static int sum(int ...a) {
    

    //定义一个结果变量
    int s = 0 ;
    for(int i = 0 ; i < a.length ; i ++) {
   
        s+=a[i] ;
    }
    return s ;
}

public static int sum(int a, int b,int c,int d) {
   
    return a + b + c +d ;
}
public static int sum(int a, int b,int c) {
   
    return a + b + c;
}
public static int sum(int a, int b) {
   
    return a + b;
}