Java（JDK1.5新特性（枚举+泛型））

最新推荐文章于 2022-05-25 11:40:15 发布

原创最新推荐文章于 2022-05-25 11:40:15 发布 · 374 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java

Java 专栏收录该内容

13 篇文章

订阅专栏

本文深入解析JDK1.5引入的六大关键特性：静态导入简化类方法调用；可变参数提升方法灵活性；增强for循环优化数组遍历；自动拆装箱减少类型转换负担；枚举类型确保类型安全；泛型机制保障代码健壮性，消除类型转换错误。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JDK1.5已经发布很长时间，之所以还拿出来是因为其增加了很多个重要的特性，使用这些特性有助于我们简化开发，编写的

代码更加简洁清晰安全，主要有以下几个特性：静态导入、可变参数、增强for循环、自动拆装箱、泛型和枚举（简单又实用）

（一）静态导入

所谓静态导入只不过是在普通的import语句中加入关键字static，例如：

非静态导入：import java.lang.Math;

静态导入：import static java.lang.Math.*;或import static java.lang.Math.max;

首先，静态导入可以导入某个类下的某个方法（静态）或所有方法，而非静态导入只能定位到某个类。其次静态二字的作

用起在静态方法的调用上，如果是非静态导入，那么调用某个类的静态方法时要用【类名 . 方法名】；如果是静态导入，那么调

用该类静态方法时就可以省去类名，直接用【方法名】即可，实例如下：

（1）非静态导入：

　　（2）静态导入：

（二）可变参数

可变参数说的是一个方法，接收的参数个数是动态可变的，使用规则：

（1）如果有多个参数，那么可变参数只能出现在参数列表的最后，public static int add(int x, int y,int...args) {…}

（2） … 位于变量类型与变量名之间（前后有无空格都可以）

（3）调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的方式访问可变参数

public class VariableParameter {

    // 封装一个方法，可以计算任意多个整数的加法的方法

    public static int add(int... args) {  // 可变参数

        int sum = 0;

        for (int i = 0; i < args.length; i++) {

            sum = sum + args[i];

        }

        return sum;

    }

    public static void main(String args[]) {

        // 测试1：计算2个整数的加法

        System.out.println(add(1, 2));

        // 测试2：计算3个整数的加法

        System.out.println(add(10, 20, 30));

    }

}

（三）增强for循环（foreach语句）

使用规则：

（1）语法，for(type 变量名 : 集合变量名){…}，例如：for(int arg : args){…}

（2）迭代变量必须在()中定义，例如：for(int arg : args){…}

（3）集合变量可以是数组或实现了Iterable接口的集合类

public class FOR {

    public static void main(String args[]){

        System.out.println(add(4));

    }

    public static int add(int x,int...args){

        int sum=0;

        //普通for循环

/*        for(int i=0;i<args.length;i++){

            sum=sum+args[i];

        }*/

        //增强for循环

        for(int arg:args){

            sum=sum+arg;

        }

        return sum;

    }

}

（四）自动拆装箱

拆装箱即引用类型与值类型的相互转化，Java 5以前都是手动的拆装箱。

（1）装箱：将基本类型转换成包装类对象（集合存放整数）

int i=10;

Integer x=new Integer(i); // 手动装箱

Integer y=10; // 自动装箱

（2）拆箱：将包装类对象转换成基本类型的值

Integer j=new Integer(8);

int m=j.intValue(); //手动拆箱

int n=j; //自动拆箱

public class AutoBox {

    public static void main(String[] args) {

        // 自动将基本数据类型(值类型)包装为Integer（引用类型）对象（装箱）

        Integer a = 1;

        Integer b = 1;

        System.out.println(a == b);// 输出true

        Integer a1 = 130;

        Integer b1 = 130;

        System.out.println(a1 == b1);// 输出false

        // 从-128到127之间的数因为用的比较频繁，所以相同的数会包装为同一个对象（如上面的a、b），这里应用了“享元模式“， -128到127之间的数由于非常常用，所以为了节省内存，自动装箱时运用到了“享元模式”。代码中Integer a = 1与 Integer b =1;看似是a、b两个对象，实际上它们指向的是同一块内存空间，而Integer a1 = 130与 Integer b1= 130;中a1、b1指向的是不同的内存空间，所以它们是两个不同的对象

        Integer a2 = Integer.valueOf(1);

        // 手动装箱

        Integer a2 = Integer.valueOf(1);

        Integer b2 = Integer.valueOf(1);

        System.out.println(a2 == b2);// 输出true

    }

}

　　 享元思想：有很多个小对象中有很多属性相同，就将它们弄成一个对象，将那些不同的属性弄成方法的参数，当需要的

时候再传递进来。相同的属性称为对象的内部状态，不同的属性称为外部状态。适合用于只是因重复而导致使用无法令人接受的

大量内存的大量物件

（五）枚举类（更加直观，类型安全）

1、使用常量会有以下几个缺陷：

　　（1）类型不安全。若一个方法中要求传入季节这个参数，用常量的话，形参就是int类型，开发者传入任意类型的int类型值

就行，但是如果是枚举类型的话，就只能传入枚举类中包含的对象。

　　（2）没有命名空间。开发者要在命名的时候以SEASON_开头，这样另外一个开发者再看这段代码的时候，才知道这四个常

量分别代表季节。

2、使用枚举类规则：

（1）enum和class、interface的地位一样

（2）使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类（枚举类可以实现一个或多个接口）