JDK1.5新特性

最新推荐文章于 2020-09-27 13:53:37 发布

原创最新推荐文章于 2020-09-27 13:53:37 发布 · 532 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

48 篇文章

订阅专栏

本文介绍了Java 1.5版本引入的重要新特性，包括静态导入、可变参数、增强for循环、自动装箱与拆箱、享元模式及枚举等内容。通过示例详细解释了这些特性的使用方法和注意事项。

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

1、静态导入：importstatic

import语句可以导入一个类或者某个包中的所有的类。

例如：import java.io.File或者import java.io.*;

import static（静态导入）语句可以导入一个类中的某个静态方法/字段，或者所有的静态方法/字段。

例如：import static java.lang.System.exit;或者import java.lang.System.*;

静态导入的好处：可以省略类名不写，直接在程序代码中调用该类的静态方法。

代码示例：

需求：求3和6的最大值，以及3减6的绝对值。

静态导入前：

package cn.itcast.day1;
 
public class StaticImport {
      public static void main(String[]args) {
         System.out.println("最大值max="+Math.max(3,6));
         System.out.println("绝对值abs="+Math.abs(3- 6));
      }
}

静态导入后：

package cn.itcast.day1;
 
//import static java.lang.Math.max;   可以静态导入某一个指定静态方法max()。
import static java.lang.Math.*;    //静态导入Math类中的所有静态方法。
 
public class StaticImport {
      public static void main(String[]args) {
         System.out.println("最大值max="+max(3, 6));//可以省掉类名不写。
          System.out.println("绝对值abs="+abs(3 -6));
      }
}

注意：如果使用JDK1.5以下的版本编译，则JDK1.5的新特性会失效，会出现报错。

2、可变参数

当参数个数不确定，参数类型确定的时候，可以使用可变参数来动态的给函数/方法传入参数并调用处理。

注意：

①、可变参数必须位于参数列表的最后面。

②、可变参数的数据类型和变量名之间是三个点...，前后有无空格都可以。

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

package cn.itcast.day1;
 
public class VarableParameter {
      public static void main(String[]args) {
         System.out.println(add(2,3));   //5
         System.out.println(add(2,3,5));    //10
         System.out.println(add(2,3,5,8));     //18
      }
  
      public static int add(int x,int... args){
         int sum = x;
         for(int i=0; i<args.length;i++){
            sum += args[i];
         }
         return sum;
      }
}

3、增强for循环（for each）

格式：for(变量类型变量名 :集合变量名){…}

注意：

①、迭代变量必须在括号()中定义。

②、集合变量可以是数组或者是实现了Iterable接口的集合类。

package cn.itcast.day1;
 
public class VariableParameter {
      public static void main(String[]args) {
         System.out.println(add(2,3));
         System.out.println(add(2,3,5));
         System.out.println(add(2,3,5,8));
      }
  
      public static int add(int x,int... args){
         int sum = x;
 
         //高级for循环
         for(int arg : args){
            sum += arg;
         }
         return sum;
      }
}

4、基本数据类型自动装箱与拆箱

代码示例：

package cn.itcast.day1;
 
public class AutoBox {
      public static void main(String[]args) {
         Integer iObj = 3; //自动装箱
          System.out.println(iObj+12); //自动拆箱
           
          Integer i1 = 137;
         Integer i2 = 137;
         //1Byte：-128~127  享元模式
         System.out.println("i1==i2："+(i1==i2));  //false
     
         Integer i3 = Integer.valueOf(13);
         Integer i4 = Integer.valueOf(13);
         System.out.println("i3==i4："+(i3==i4));  //true
      }
}

享元模式（Flyweight Pattern）：

是一种软件设计模式。就是将很多很小的且内容相同的对象做为一个大的对象。如果还有很多不同内容的对象，则可以将它们做为参数传入。

享元模式的作用：

可以将要被频繁使用的一定范围的数据缓存起来，当需要使用的数据在这个范围之内的话，就直接从该缓存区域当中取，这样可以大大的节约内存空间。

例如：以上示例当中的Intege对象的数值如果在-128~127这个范围之内，则相同数值的两个不同名称的对象就表示的是同一个对象，发挥true。如果超出了这个数值范围，则返回false。

5、枚举

①、什么是枚举？

枚举就相当于一个类，其中可以定义构造方法、成员变量、普通方法和抽象方法等。

②、枚举的作用：可以限制一个类的对象产生范围，并对JDK1.5之前的类集进行了扩充，为使用枚举提供便利。

③、为什么要使用枚举（Enum）？

JDK1.5之前，要限定一个类的对象的产生范围，需要做很多的操作才能实现目的，并且也容易带来各种不安全的问题。而JDK1.5之后引入的枚举类型则可以避免这些问题。

代码示例：使用普通的类来完成枚举的功能

package cn.itheima.demo;
 
class Color{
      //定义三种颜色，限定该类的对象只有这三个。
       public static final Color RED = new Color("红色");    //定义本类对象。
       public static final Color GREEN = new Color("绿色");
      public static final Color BLUE = new Color("蓝色");
  
      private String name;
      private Color(String name){     //将构造函数私有，防止外部其他类建立此类对象。只能使用本类中已经创建好的对象。
         this.setName(name);
      }
      public String getName() {
         return name;
      }
      public void setName(String name) {
         this.name = name;
      }
  
      //定义获取颜色的静态方法，只能从固定的几个颜色中选择。
      public static Color getInstance(int i){
         switch(i){
            case 1:{
               return RED;
            }
            case 2:{
               return GREEN;
            }
            case 3:{
               return BLUE;
            }
            default:{
               return null;
            }
         }
      }
}
 
public class ColorDemo1 {
      public static void main(String[]args) {
         Color c1 = Color.RED;
         System.out.println(c1.getName());
     
         Color c2 = Color.getInstance(3);    //根据编号获取颜色。
          System.out.println(c2.getName());
      }
}

④、枚举的定义：使用关键字enum可以直接定义枚举类。

声明格式：

[public] enum枚举类名称{

枚举对象1,枚举对象2,…,枚举对象n;

}

注意：

a.可以使用“枚举类名.变量”的形式调用枚举中的指定内容。

b.枚举对象列表末尾的分号可有可无，但前提是枚举对象列表后面不能有任何其它内容。

c.枚举的修饰符只能是public或者默认权限的修饰符。

代码示例：枚举的声明以及常用方法的使用

package cn.itcast.day1;
 
public class EnumTest {
         public static void main(String[] args) {
            WeekDay weekDay2 = WeekDay.FRI;
            System.out.println(weekDay2);     //FRI
            System.out.println(weekDay2.name());    //FRI
            System.out.println(weekDay2.ordinal());     //5
            System.out.println(WeekDay.valueOf("SUN").toString());
            System.out.println(WeekDay.values().length);     //7 使用values()方法将所有的枚举对象变成对象数组，再输出数组的长度。
      }
  
      //枚举类的声明。
      public enum WeekDay{
         SUN,MON,TUE,WED,THI,FRI,SAT;    //枚举对象。
      }
}

⑤、实现带有构造方法的枚举

注意：

①、枚举类中定义的所有其它信息（例如：构造方法、成员）都必须要放在枚举对象列表之后。但是枚举对象列表末尾必须要加上分号，否则编译会报错。

②、枚举类中的构造方法必须是私有的（被private修饰）。

③、可以在枚举对象的后面加上一对括号()，可以通过在括号中加入指定的内容，表示用来调用相对应的构造方法。不加括号，或者是空括号则表示调用空参数的构造方法。

代码示例：

package cn.itcast.day1;
 
public class EnumTest {
       public static void main(String[] args) {
              WeekDay weekDay2 = WeekDay.FRI;
}
         //枚举类的声明。
       public enum WeekDay{
              SUN(1),MON,TUE,WED,THI,FRI,SAT;  //枚举对象。
        
              private WeekDay(){
                     System.out.println("first");
              }
              private WeekDay(int day){
                     System.out.println("second");
              }
       }
}

⑥、实现带有抽象方法的枚举

package cn.itcast.day1;
 
public class EnumTest {
       public static void main(String[]args) {
              System.out.println(TrafficLamp.RED.nextLamp());
              System.out.println(TrafficLamp.GREEN.nextLamp());
              System.out.println(TrafficLamp.YELLOW.nextLamp());
       }
 
       public enum TrafficLamp{
            RED(30){
               public TrafficLamp nextLamp(){
                   return GREEN;
               }
            },
            GREEN(45){
               public TrafficLampnextLamp(){
                  return YELLOW;
               }
            },
            YELLOW(5){
               public TrafficLampnextLamp(){
                  return RED;
               }
            };
        
            public abstract TrafficLampnextLamp();
            private int time;
            private TrafficLamp(int time){
               this.time = time;
            }
       }
}

注意：可以使用枚举来实现单例操作。