java SE 增强

Java SE 增强

JDK 5.0 新特性

“JDK 5.0” 的一个重要主题就是通过新增一些特性来简化开发，这些特性包括：

静态导入

自动装包/拆包

for-each循环

可变参数

枚举

泛型

元数据

使用这些特性有助于编写更加清晰，精悍，安全的代码。

静态导入

JDK 1.5 增加的静态导入语法用于导入指定类的某个静态属性值(方法)或全部静态属性值(方法)

语法：

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

静态导入语句使用 import static 语句

导入指定类的单个静态属性:                             

     import static java.lang.System.out

导入指定类静态方法
 import static java.lang.Math.max

导入指定类全部静态属性和方法                                  

     import static java.lang.Math.*

自动装箱/拆箱

自动装箱(autoboxing)：把一个基本数据类型直接赋给对应的包装类变量, 或者赋给 Object 变量

自动拆箱：把包装类对象直接赋给一个对应的基本类型变量

典型应用：

List list = new ArrayList();

list.add(1);

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

增强for循环

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

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

使用 foreach 循环遍历数组和集合元素时, 无须获得数组和集合长度, 无须根据索引来访问数组元素和集合元素, foreach 循环自动遍历数组和集合的每个元素

语法格式：

for ( type 变量名：集合变量名 )  { … }

           for(type varName : array | collection){

                  //varName 自动迭代访问每一个元素

            }

枚举类

为什么需要枚举？

一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，此类问题在JDK5以前采用自定义带有枚举功能的类解决，Java5以后可以直接使用枚举予以解决。

JDK 5新增的 enum 关键字用于定义一个枚举类。

枚举类练习

   设计一个Student类

   class  Student｛

   private String name;

   private Grade grade;

   ……}

  要求：学生的grade只能是a，b，c，d，e五个级别。可以给学生设置成绩，并可以输出学生成绩情况（优，良，中，可，差）

手动实现枚举类：

通过 private 将构造器隐藏起来

把这个类的所有可能实例都使用 public static final 修饰

属性不应允许被改动, 所以应该使用 private final 修饰

 

 

 

 

 

 

 

上面写法比较麻烦，java中提供了一种更方便的方法----枚举类可以解决上面的问题

JDK 1.5 新增的 enum 关键字用于定义枚举类

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

枚举类和普通类的区别：

使用 enum 定义的枚举类默认继承了 java.lang.Enum 类

枚举类的构造器只能使用 private 访问控制符

枚举类的所有实例必须在枚举类中显式列出(, 分隔    ; 结尾). 列出的实例系统会自动添加 public static final 修饰

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

若枚举只有一个成员, 则可以作为一种单例模式的实现方式

 

枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰

枚举类的使用 private final 修饰的属性应该在构造器中为其赋值

若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的传入参数

例子

package com.hbsi.base;

 

import java.util.*;
import java.util.Map.Entry;

import org.junit.Test;

public class Demo3 {

 /**
  * @param args
  */
 /*public static void main(String[] args) {
  Demo3 d=new Demo3();
  d.testArr();

 }*/
 @Test              //Junit
 public void testArr(){
  String[] name={"aa","bb","cc"};
  for(String str:name){
   System.out.println(str);
  }
 }
 @Test
 public void testArr1(){
  Person[] persons=new Person[3];
  persons[0]=new Person("张1",34);
  persons[1]=new Person("张2",24);
  persons[2]=new Person("张3",31);
  
  for(Person p:persons){
   System.out.println(p.getName()+".."+p.getAge());
  }
 }
 @Test
 public void test3(){
  List<String> list=new ArrayList<String>();
  list.add("aaa");
  list.add("bbb");
  list.add("ccc");
  
  for(String str:list){
   System.out.println(str);
   
  }
  
 }
 @Test
 public void test4(){
  List<Person> list=new ArrayList<Person>();
  list.add(new Person("lisi1",23));
  list.add(new Person("lisi2",41));
  list.add(new Person("lisi3",44));
  
  for(Person p:list){
   System.out.println(p.getName()+"..."+p.getAge());
  }
 }
 @Test
 public void testMap(){
  Map map=new LinkedHashMap();
  map.put("1","aaa");
  map.put("2","bbb");
  map.put("3","ccc");
  
  //通过map.keySet()把键值取出，遍历
  /*Set keys=map.keySet();
  Iterator it=keys.iterator();
  while(it.hasNext()){
   String key=(String)it.next();
   String value=(String)map.get(key);
   System.out.println(key+"="+value);
  }*/
  //使用map.entrySet()方法
  /*Set set=map.entrySet();
  Iterator it=set.iterator();
  while(it.hasNext()){
   Map.Entry me=(Map.Entry) it.next();
   String key=(String)me.getKey();
   String value=(String)me.getValue();
   System.out.println(key+"="+value);
  }*/
  
  //for循环
  
  for(Object obj:map.entrySet()){
   Map.Entry me=(Map.Entry)obj;
   System.out.println(me.getKey()+"="+me.getValue());
  }
  
 }
 //for循环不能够改变数组元素的值，只起到遍历的作用
 @Test
 public void test5(){
  int[] arr=new int[5];
  for(int num:arr){
   //num=1;
   System.out.println(num);
  }
  System.out.println(arr[0]);
 }

}