黑马程序员-----java5的新特性

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、静态导入

[java] view plain copy

1. import static java.lang.Math.*;  
2.    
3. public class StaticImport {  
4.     public static void main(String[] args) {  
5.         System.out.println(max(5, 1));  
6.         System.out.println(max(5, 9));  
7.     }  
8. }  

二、可变参数

         特点：可变参数只能出现在参数列表的最后，调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

[java] view plain copy

1. public class VariableParameter {  
2.     public static void main(String[] args) {  
3.         System.out.println(add(new int[] { 1, 2, 3 }));  
4.     }  
5.    
6.     public static int add(int... nums) {  
7.         int sum = 0;  
8.    
9.         for (int num : nums) {  
10.             sum += num;  
11.         }  
12.    
13.         return sum;  
14.     }  
15. }  

三、增强的for循环

增强的for循环的加入简化了集合的遍历

其语法如下

– for(type element :array) {

       System.out.println(element)....

   }

四、枚举（Enums）

JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enum. 我们可以这样来定义一个枚举类型：

public enum Color

{   Red,  White, Blue  }                       

然后可以这样来使用Color myColor = Color.Red.

         枚举类型可用于设计单例模式的类。

l  实例：定义有参构造函数、含抽象方法的枚举类型

[java] view plain copy

1. public enum TrafficLamp {  
2.     RED(30) {  
3.         @Override  
4.         public TrafficLamp nextLamp() {  
5.             return GREEN;  
6.         }  
7.     },  
8.     GREEN(45) {  
9.    
10.         @Override  
11.         public TrafficLamp nextLamp() {  
12.             return YELLOW;  
13.         }  
14.     },  
15.     YELLOW(5) {  
16.         @Override  
17.         public TrafficLamp nextLamp() {  
18.             return RED;  
19.         }  
20.     };  
21.    
22.     public abstract TrafficLamp nextLamp();  
23.    
24.     private int time;  
25.    
26.     private TrafficLamp(int time) {  
27.         this.time = time;  
28.     }  
29. }  

五、泛型(Generic)

      泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小地抛出ClassCastExceptions的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的类型。 

实例：在集合类中使用泛型

[java] view plain copy

1. import java.util.*;  
2. import java.util.Map.Entry;  
3.    
4. public class GenericTest {  
5.     public static void main(String[] args) throws Exception {  
6.         HashMap<String, Integer> map = new HashMap<String,Integer>();  
7.         map.put("fengyan", 22);  
8.         map.put("hello", 23);  
9.         Set<Entry<String, Integer>> keySet =map.entrySet();  
10.         for (Entry<String, Integer> key : keySet) {  
11.             System.out.println(key.getKey()+": "+key.getValue());  
12.         }  
13.     }  
14. }  

实例：自定义泛型类

[java] view plain copy

1. import java.util.Set;  
2. public class BaseDao<E> {  
3.     public void save(E obj) {   }  
4.     public E findById(Integer id) {     return null;    }  
5.     public void delete(E obj) { }  
6.     public void delete(Integer id) {    }  
7.     public void update(E obj) { }    
8.     public Set<E> findByconditions(String where){   return null;}  
9. }  

实例：通过反射获得泛型的实际类型参数

[java] view plain copy

1. import java.lang.reflect.*;  
2. import java.util.*;  
3.    
4. public class GenericTest {  
5.     public static void main(String[] args) throws Exception {  
6.         Method method = GenericTest.class.getMethod("applyList", List.class);  
7.    
8.         Type[] types = method.getGenericParameterTypes();  
9.         ParameterizedType pType = (ParameterizedType) types[0];  
10.    
11.         types = pType.getActualTypeArguments();  
12.    
13.         System.out.println(types[0]);  
14.     }  
15.    
16.     public static void applyList(List<Date> list) {  
17.     }  
18. }