黑马程序员---JDK5.0新特性(上)

------- android培训、java培训、期待与您交流！ ----------

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

静态导入   自动装箱/拆箱   增强for循环  可变参数  枚举反射内省  泛型  元数据

1、静态导入

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

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

例如：

import static java.lang.System.out
import static java.lang.Math.*
//Demo1
package cn.itcast.demo;
import static java.lang.System.out; 
import static java.util.Arrays.*;

public class Demo1 {
	public static void main(String[] args) {
		out.print("main");
		int []a=new int[]{6,5,3};
		sort(a);
		for(int i:a)
			out.print(i);
	}
}

2、自动装箱、拆箱

JDK5.0的语法允许开发人员把一个基本数据类型直接赋给对应的包装类对象（变量）, 或者赋给 Object 类型的变量，这个过程称之为自动装箱。

自动拆箱与自动装箱与之相反，即把包装类对象直接赋给一个对应的基本类型变量。

例如：

package cn.itcast.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo2 {
	public static void main(String[] args) {
		Integer i=1;//装箱
		int j=i;//拆箱
		//典型应用
		List list = new ArrayList();
		list.add(1);
		int k = (Integer)list.get(0);
		Iterator it=list.iterator();
		while(it.hasNext())
		{
			int m=(Integer)it.next();//拆箱
		}
	}
}

注意：Integer i = null ;int m = i 会出现空指针异常

3、增强for循环

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

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

语法格式：

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

         }

Map map=new HashMap();
//Map map2=new LinkedHashMap<K, V>();
map.put("1", "aaa");
map.put("2", "bbb");
map.put("3", "ccc");
//传统方式1
Set set=map.keySet();
Iterator it=set.iterator();
while(it.hasNext()){
	String key=(String)it.next();
	String value=(String) map.get(key);		
        System.out.println("key="+key+",value="+value);
}
//传统方式2
Set set2=map.entrySet();
Iterator it2=set2.iterator();
while(it2.hasNext()){
	Map.Entry  entry=(Entry)it2.next();			
        System.out.println("key="+entry.getKey()+",value="+entry.getValue());
		}
//增强for循环的1种方式
for(Object obj:map.keySet()){
	String key2=(String)obj;
	String value2=(String)map.get(key2);			
        System.out.println("key2="+key2+",value2="+value2);
}
//增强for循环的2种方式
for(Object obj:map.entrySet()){
	Map.Entry entry3=(Entry) obj;
	String key3=(String) entry3.getKey();
	String value3=(String) entry3.getValue();
	System.out.println("key3="+key3+",value3="+value3);
}
//增强for循环需要注意的问题：只适合取数据
int arr[]={1,2,3};
for(int i: arr){
		i=10;
	}
System.out.println(arr[0]); // 1
List li=new ArrayList();
li.add("1");
for(Object obj : li){
	obj="888";
}
System.out.println(li.get(0));// 1

4、可变参数

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

                   publicvoid foo(int … args){

                   }

注意事项：

调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的可变参数，因此，可以在方法体中以数组的形式访问可变参数

可变参数只能处于参数列表的最后, 所以一个方法最多只能有一个长度可变的参数

public void testSum(){
		sum(1,2,3,4);
		int arr[]={5,6,7};
		sum(arr);
	}
	public void sum(int ...nums){
		//可变参数当成数组
		int sum=0;
		for(int i:nums){
			sum+=i;
		}
		System.out.println(sum);		
	}

public void  bb(){
		//public static <T> List<T>asList(T... a)
		List list=Arrays.asList("1","2","3");
		System.out.println(list);//[1, 2, 3]
		
		String arr[]={"1","2","3","4"};
		list=Arrays.asList(arr);
		System.out.println(list);//[1, 2, 3, 4]

		//当是基本数据类型数组时
		int nums[]={1,2,3,4,5};
		list=Arrays.asList(nums);
		System.out.println(list);//[[I@120d62b]
		
		Integer nums2[]={1,2,3,4,5};
		list=Arrays.asList(nums2);
		System.out.println(list);//[1, 2, 3, 4, 5]
		
	}

可变参数注意的问题

        publicvoid aa(int ...nums,int s){}//不可以

        publicvoid bb(int s ,int ...nums){}//可以

5、枚举

枚举类具有如下特性：

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

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

与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数，但枚举类的构造函数必须为私有的（这点不难理解）。

枚举类也可以实现接口、或继承抽象类。

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

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

Java中声明的枚举类，均是java.lang.Enum类的孩子，它继承了Enum类的所有方法。常用方法：

name()

ordinal()//返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

valueof(Class enumClass, String name) //返回带指定名称的指定枚举类型的枚举常量。

//String str=”B”;Gradeg=Grade.valueOf(Grade.class,str);

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便。

普通类模拟枚举：

package cn.itcast.enumeration;
import org.junit.Test;
public class Demo1 {
	@Test
	public void test() {
		print(Grade.B);
	}

	public void print(Grade g) // A B C D E
	{
		String value=g.getValue();
		System.out.println(value);
	}
}

/*
 * class Grade{ 
 *  private Grade(){ }
 *  public static final Grade A=new Grade();
 *  public static final Grade B=new Grade();
 *  public static final Grade C=new Grade(); 
 *  public static final Grade D=new Grade();
 *  public static final Grade E=new Grade(); 
 *  }
 */

//如何定义枚举的构造函数、方法、字段
enum Grade {// class A 100-90 B 89-80 C 79-70 D 69-60 E 59-0
	A("100-90"), B("89-80"), C("79-70"), D("69-60"), E("59-0");// object
	private String value;
	private Grade(String value){
		this.value=value;
	}
	public String getValue(){
		return this.value;
	}

枚举是一个终极类，不能被继承，但是可以有抽象方法，声明枚举值得时候只能用匿名内部类的形式

package cn.itcast.enumeration2;
import org.junit.Test;
public class Demo1 {
	@Test
	public void test() {
		print(Grade.B);	//89-80,良	
	}

	public void print(Grade g) // A B C D E
	{
		String value=g.getValue();
		String value2=g.localeValue();
		
		System.out.println(value+","+value2);
	}
}

//带抽象方法的枚举
enum Grade {// class A 100-90优 B 89-80良 C 79-70 一般D 69-60差 E 59-0不及格
	A("100-90"){
		public String localeValue(){
			return "优";
		}
	},
	B("89-80"){
		public String localeValue(){
			return "良";
		}
	},
	C("79-70"){
		public String localeValue(){
			return "一般";
		}
	},
	D("69-60"){
		public String localeValue(){
			return "差";
		}
	}, 
	E("59-0"){
		public String localeValue(){
			return "不及格";
		}
	};// object
	
	private String value;
	private Grade(String value){
		this.value=value;
	}
	public String getValue(){
		return this.value;
	}
	public abstract String localeValue();
}

------- android培训、java培训、期待与您交流！ ----------