黑马程序员——JDK5.0新特性

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1  JDK5特性

JDK5中新增了很多新的java特性，利用这些新语法可以帮助开发人员编写出更加清晰，安全，高效的代码。

静态导入

自动装箱/拆箱

增强for循环

可变参数

枚举

 

泛型

1.1   静态导入（了解）

JDK 1.5增加的静态导入语法用于导入类的某个静态属性或方法。使用静态导入可以简化程序对类静态属性和方法的调用。

语法：

import static包名.类名.静态属性|静态方法|*

例如：

import static java.lang.System.out

import static java.lang.Math.*

 

 

importstatic java.lang.System.out;

importstatic java.lang.Math.*;

 

publicclass Demo {

 

   publicstaticvoid main(String[] args) {

      //普通写法

      System.out.println("hello world");

      int max = Math.max(100, 200);

      System.out.println(max);

 

      //静态导入

      out.println("hello world");

      int max2 =max(100, 200);

      System.out.println(max2);

   }

   

}

 

 

1.2   增强for循环

引入增强for循环的原因：在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！

因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。增强for循环只能用在数组、或实现Iterable接口的集合类上

语法格式： 

for(变量类型变量　：需迭代的数组或集合){}

 

                                           

For each是为了让你的代码变得简捷、和容易维护。

 

增强for循环要注意的细节：

   1. 迭代器可以对遍历的元素进行操作，使用增强for循环时，不能对集合中的元素进行操作的。

2.增加for循环与普通的for循环区别。

3. map的遍历。

1.3   可变参数

JDK中具有可变参数的类Arrays.asList()方法。

分别传多个参、传数组，传数组又传参的情况。

注意：传入基本数据类型数组的问题。

从JDK 5开始, Java 允许为方法定义长度可变的参数。

语法：数据类型…变量名。

可变长参数是Object[]数组。（可变参数里存的是对象数组）

JDK中的典型应用：

    Arrays.asList(T…a)是jdk中的典型应用。

需求:对若干个整数进行求和

publicstaticint sum1(inta,int b ) {

      return a+b;

   }

 

若干个整数求和如何解决？

可以使用数组接收整数。

publicstaticint sum1(int[] numbers) {

      if (numbers ==null) {

          return 0;

      }

 

      if (numbers.length == 0) {

          return 0;

      }

 

      int sum = 0;

      for (int num : numbers) {

          sum += num;

      }

      return sum;

   }

 

 

可以使用可变参数

publicstaticint sum2(int... numbers) {

      if (numbers ==null) {

          System.out.println("可变参数的值为null");

          return 0;

      }

 

      if (numbers.length == 0) {

          System.out.println("可变参数的值的长度为0");

          return 0;

      }

 

      int sum = 0;

      for (int num : numbers) {

          sum += num;

      }

      return sum;

   }

 

 

可变参数的使用

publicstaticvoid main(String[] args) {

      //int result = sum1(new int[] { 1, 3, 5, 7, 9 });

      // System.out.println(result);

 

      // //使用了可变参数，传一个数组进去

      //int result = sum2(new int[] { 1, 3, 5, 7, 9 });

      // System.out.println(result);

 

      //使用了可变参数，不必声明数组，简化书写

      //int result = sum2(2, 4, 6, 8, 10);

      //int result = sum2(1);

      int result =sum2();

      System.out.println(result);

   }

 

 

 

可变参数的细节

声明：

      在一个方法中，最多只能有一个可变参数。

      可变参数只能放在参数列表的最后面。

   调用：

      当使用可变参数时，可以传0或多个参数。

      当使用可变参数时，也可以传一个数组进去，就表示多个参数。

   使用：

      在方法内部使用时，就是在使用一个数组。

      当调用时没有传参数时（传了0个），这时在方法内部的参数数组是有值的（不为null），但长度为0.

 

 

1.4   自动装箱/拆箱

自动装箱：指开发人员可以把一个基本数据类型直接赋给对应的包装类。

自动拆箱：指开发人员可以把一个包装类对象直接赋给对应的基本数据类型。

典型应用：

   List list = new ArrayList();

   list.add(1);

   //list.add(new Integer(1));

   int i=list.get(0);

   //int j = (Integer)list.get(0);

 

1.4.1基本数据类型包装类

包装类                                基本数据类型

Byte

byte

Short

short

Integer

int

Long

long

Boolean

boolean

Float

float

Double

double

Character

char

对象变基本数据类型:拆箱

基本数据类型包装为对象:装箱

 

为了使得java的基本类型有更多的功能，java为其所有的基本类型提供了包装类来封装常见的功能。如：最大值、数值转换等。

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

所属的包：java.lang.*

 

常见应用一:

获取最大最小值MAX_VALUE / MIN_VALUE

整数类型最大值

Integer.MAX_VALUE

System.out.println(Integer.MIN_VALUE);// -2147483648

System.out.println(Integer.MAX_VALUE);// 2147483647

 

应用二:

基本数据类型和字符串之间的转换

例：Integer的parseInt方法，intValue方法

 

基本数据类型转换成字符串:

1:基本数据类型+””

2:基本数据类型.toString(基本数据类型值);

例如 Integer.toString(34); //将34变成了”34”

基本数据类型转字符串

inti=100;

      String str=100+"";

      String string = Integer.toString(100);

 

 

字符串变基本数据类型

基本数据类型 a=基本数据类型包装类.parse基本数据类型(String str);

str="123";

      int parseInt = Integer.parseInt(str);

      System.out.println(parseInt);

        

注意:

public static int parseInt(String s)

Integer类中的parseInt方法是静态的参数必须是数字格式

 

 

Double

str ="3.14";

      double parseInt2 = Double.parseDouble(str);

      System.out.println(parseInt2);

 

booleanb = Boolean.parseBoolean("true");

 

应用三:

进制转换:

 十进制转成其他进制.

toBinaryString(int i)
          以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

toHexString(int i)
          以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

toOctalString(int i)
          以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

那么其他进制转成十进制

parseInt(String radix);

parseInt(String s, int radix)
          使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

 

 

十进制转其他进制

//十进制转二进制

      String binaryString = Integer.toBinaryString(100);

      System.out.println(binaryString);// 1100100

      //十进制转十六进制

      String hexString = Integer.toHexString(100);

      System.out.println(hexString);// 64

 

      //十进制转八进制

      String octalString = Integer.toOctalString(100);

      System.out.println(octalString);// 144

 

 

其他进制转十进制

//字符串转对应的进制

      int parseInt3 = Integer.parseInt(octalString);

      System.out.println(parseInt3);

      //二进制转十进制

      int parseInt4 = Integer.parseInt(binaryString, 2);

      System.out.println(parseInt4);

      //十六进制转十进制

      int parseInt5 = Integer.parseInt(hexString, 16);

      System.out.println(parseInt5);

      //八进制转十进制

      int parseInt6 = Integer.parseInt(octalString, 8);

      System.out.println(parseInt6);

 

JDK5.0后出现了自动装箱和拆箱

JDK5.0以后，简化了定义方式。

Integer x =new Integer(5);//装箱

      intintValue = x.intValue(); //拆箱

 

      // 5.0简化书写

      //自动装箱。new Integer(5);

      Integer y = 5; 

      //对象加整数,x进行了自动拆箱,变成了int型和5进行加法运算后再将和进行装箱赋给x。

      y = y + 5; //是通过Integer.intValue()方法进行拆箱

 

练习:

publicstaticvoid main(String[] args) {

      Integer a = 127;

      Integer b = 127;

      System.out.println(a == b);

 

      Integer c = 128;

      Integer d = 128;

      System.out.println(c == d);

   }

请问结果?

  a==b 为true因为a和b指向了同一个Integer对象.

  Integer的缓存大小-128 ~127之间也就是byte的范围。

1.5   枚举类

枚举类具有如下特性：

枚举类也是一种特殊形式的Java类。

枚举类中声明的每一个枚举值代表枚举类的一个实例对象。

与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数.

publicclass Demo1 {

   publicstaticvoid main(String[] args) {

      Gender male = Gender.MALE;

      System.out.println(male.getInfo());

   }

}

 

enum Gender {

   MALE("男"),FEMALE;

 

   //成员变量

   private Stringinfo;

 

   //构造函数

   private Gender() {

 

   }

 

   private Gender(String info) {

      this.info = info;

   }

 

   //成员方法

   public String getInfo() {

      returninfo;

   }

 

}

枚举类可以声明抽象方法,但是要有具体的枚举值去实现.

publicclass Demo1 {

   publicstaticvoid main(String[] args) {

      Gender male = Gender.MALE;

      System.out.println(male.getInfo());

      male.speak();

   }

}

 

enum Gender {

   MALE("男") {

      @Override

      publicvoid speak() {

          System.out.println("是男人");

      }

   },

   FEMALE {

      @Override

      publicvoid speak() {

          System.out.println("是女人");

      }

   };

 

   //成员变量

   private Stringinfo;

 

   //构造函数

   private Gender() {

 

   }

 

   private Gender(String info) {

      this.info = info;

   }

 

   //成员方法

   public String getInfo() {

      returninfo;

   }

 

   publicabstractvoid speak();

 

}

 

枚举类也可以实现接口(序列化)、或继承抽象类。

JDK5中扩展了swith语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型(enum)。

publicclass Demo2 {

   publicstaticvoid main(String[] args) {

      WeekDay mon = WeekDay.MON;

      switch (mon) {

      caseMON:

          System.out.println("星期一要上班...");

          break;

      caseTUE:

          System.out.println("星期二,继续上班...");

          break;

      }

   }

}

 

enum WeekDay {

   MON,TUE, WED,THU,FRI,SAT,SUN;

}

 

 

若枚举类只有一个枚举值，则可以当作单态设计模式使用。

练习：

请编写一个关于星期几的枚举WeekDay，要求：枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun该枚举要有一个方法，调用该方法返回中文格式的星期。

enum WeekDay {

   MON {

 

      @Override

      public String getInfo() {

 

          return"星期一";

      }

 

   },

   TUE {

      @Override

      public String getInfo() {

 

          return"星期二";

      }

   },

   WED {

      @Override

      public String getInfo() {

 

          return"星期三";

      }

   },

   THU {

      @Override

      public String getInfo() {

 

          return"星期四";

      }

   },

   FRI {

      @Override

      public String getInfo() {

 

          return"星期五";

      }

   },

   SAT {

      @Override

      public String getInfo() {

 

          return"星期六";

      }

   },

   SUN {

      @Override

      public String getInfo() {

 

          return"星期天";

      }

   };

 

   publicabstract String getInfo();

}