Java——JDK1.5新特性-可变参数、foreach循环、静态导入

一、可变参数

现在假设说有这样的要求：要求设计一个方法，用于计算任意参数的整数的相加结果。这个需求在早期只能通过数组的方式来实现。

早期实现方法

public class Test {
    public static void main(String[] args) {
        System.out.println(add(new int[]{1}));
        System.out.println(add(new int[]{1,2,3}));
        System.out.println(add(new int[]{1,2,3,4,5,6,7,8}));
    }
    public static int add(int[] data) {
        int result = 0 ;
        for (int i = 0; i < data.length; i++) {
            result += data[i] ;
        }
        return result ;
    }
}

这种最初的实现方式本身存在缺陷，现在要求设计的不是数组，而是任意多个参数。所以从JDK1.5之后追加了可变参数的概念。

定义方式：数据类型 ... 可变参数名称

public class Test {
    public static void main(String[] args) {
        System.out.println(add(1,2,3));
        System.out.println(add(4,5,6,7,8));
        System.out.println(add(5,7,9,1,5,3,8,1,8));
    }
    public static int add(int ... data) {
        int result = 0 ;
        for (int i = 0; i < data.length; i++) {
            result += data[i] ;
        }
        return result ;
    }
}

这里add方法的参数，是int ... data，这样定义的方法可以传进去任意多个整型参数。可变参数本质还是数组。

注意：一个方法中只允许有一个可变参数，并且可变参数一定是方法最后一个参数。

一个方法中如果有2个可变参数，编译器无法区分，因为每个参数都是任意长度的，编译器不知道什么时候传的是第二个可变参数。一个方法中可以有普通参数和一个可变参数，并且可变参数一定要放到最后。这样编译器就会知道第一个参数是普通参数，后面的都是可变参数

public class Test {
    public static void main(String[] args) {
        System.out.println(add2(1,2,3));
        System.out.println(add2(4,5,6,7,8));
        System.out.println(add2(5,7,9,1,5,3,8,1,8));
    }
    public static int add2(int n, int ... data){
        int result = 0;
        for(int i = 0; i < data.length; i ++){
            result += data[i];
        }
        result += n;
        return result;
    }
}

二、foreach循环

foreach循环是for循环的加强版，只用于数组、类集内容的取得，不能修改原数组、类集内容

使用方式：for(数据类型  临时变量 ：数组名/类集名){}

public class Test {
    public static void main(String[] args) {
        int[] num = {1,2,3,4,5,6};
        for (int temp :num) {
            System.out.print(temp + ",");
        }
    }
}

通过此方式可以很好的避免数组越界的问题，但是这种数组的操作只适合简单输出模式。

三、静态导入

将一个类的所有静态域（包含静态属性、方法）全部导入到使用类中，此时调用属性和方法不需要加类名。

写一个MyMath类

public class MyMath {
    public static int Add(int x,int y){
        return x + y;
    }
    public static int Sub(int x,int y){
        return x - y;
    }
}

这个类中都是静态方法

再写个测试类

import static StaticImport.MyMath.*;

public class Test {
    public static void main(String[] args) {
        System.out.println(Add(1,2));
        System.out.println(Sub(8,2));
    }
}

该类中所有方法均为静态方法，于是按照最初的使用原则。首先导入MyMath类，然后通过MyMath类调用所有静态
方法。从JDK1.5开始，如果类中方法全是static方法，则可以直接把这个类的方法导入进来，这样就好比像在主类中定义的
方法那样，可以被主方法直接调用。