jdk5.0以及5.0之后的版本:

package java静态导入;
import static java.lang.System.out;		//用的不多,可阅读性下降
import org.junit.Test;

public class Demo {

		@Test
		public void test(){
			out.print("静态导入测试");
		}
}

package 可变参数;

import org.junit.Test;

public class Demo {
	
	
	@Test
	public void testSum(){
		System.out.println(sum(1,2,3,4,5,6));
		System.out.println(sum(1,2));
	}
	
	//可变参数，就把参数看成数组,参数也可以传送一个数组
	public int sum(int ...nums){
		int sum = 0; 
		
		for(int num : nums){
			sum = sum +num;
		}
		
		return sum;
	}
	
	@Test
	public void testSum2(){
		sum2(1,2,3,4);
	}
	
	//可变参数需要注意的问题 public void sum2(int  ...nums , int x )这样写有错，可变参数必须放在最后一个参数
	public void sum2(int x ,int  ...nums){
		System.out.println("X:"+x);
	}
}

package 增强for循环;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

//能否使用增强for循环的关键是：该类是否继承了util接口
public class Demo {

	@Test
	public void test() {
		int[] arr = { 1, 2, 3, 4 };

		for (int num : arr) {
			System.out.println(num);
		}
	}

	// java.util.List 使用增强for循环
	@Test
	public void test2() {
		List list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);

		for (Object num : list) {
			int i = (Integer) num;
			System.out.println(i);
		}
	}

	@Test
	public void test3() {
		Map map = new HashMap();

		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 = it.next().toString();
			String value = http://www.mamicode.com/map.get(key).toString();>

package 自动装箱和拆箱;

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

import org.junit.Test;

//自动装箱和拆箱：基本数据类型和对象数据类型的自动转换
public class Demo {
	
		@Test
		public void test(){
			Integer i = 1; //后台自动装箱，执行 -> Integer i = new Integer(1); 
			
			//典型应用
			List list = new ArrayList<Integer>();	//集合中只能存放对象     new ArrayList<int>()会报错
			list.add(1);	//list.add(new Integer(1));
			list.add(new Integer(2));
			list.add(3);
			list.add(4);
			
			Iterator<Integer> it = list.iterator();
			
			while(it.hasNext()){
				System.out.println(it.next());  //拆箱
			}
		}
}

package 枚举;

import org.junit.Test;

public class Demo {

	@Test
	public void test() {
		print(Grade.A);
	}

	public void print(Grade g) {
		String value = http://www.mamicode.com/g.getValue();>
package 枚举;

import org.junit.Test;

//带抽象方法的枚举
public class Demo带抽象方法的枚举类型 {
	@Test
	public void test() {
		print(Grade2.A);
	}

	public void print(Grade2 g) {
		System.out.println(g.getLocalValue());
	}
}

enum Grade2 {	//枚举类型其实就是特殊的类
	A("100-90") {	//每一个枚举值代表了枚举类型中的一个对象实例
		public String getLocalValue() { // 内部类实现了Grade2的getLocalValue的抽象方法
			return "优";
		}
	},						//当枚举类型中只有一个值的时候，其相当于单态设计模式
	B("89-80") {
		public String getLocalValue() {
			return "良";
		}
	},
	C("79-70") {
		public String getLocalValue() {
			return "中";
		}
	},
	D("69-60") {
		public String getLocalValue() {
			return "及格";
		}
	},
	E("59-0") {
		public String getLocalValue() {
			return "不及格";
		}
	};
	private String value;

	private Grade2(String value) {	//枚举类的构造函数必须是私有的,因为枚举类型的实例化只能出现在枚举类的内部
		this.value = http://www.mamicode.com/value;>
package 枚举;

import org.junit.Test;

public class Demo常用的枚举方法 {

	@Test
	public void Test(){
		String a = "A";
		System.out.println("名称"+Example.A.name());
		//存在为String类型的a时，不会报错，否则会抛出异常，常常用来判断表单提交的数据中是否为某个枚举类型中的值
		System.out.println("存在该值"+Example.valueOf(a));	//用的比较多
		
		System.out.println("在声明的枚举类型中的位置:"+Example.B.ordinal());//下标从0开始计算
		
		//遍历枚举类型
		Example[] exs = Example.values();
		for(Example value : exs)
		System.out.print(value+" ");
	}
}

enum Example{
	A,B,C,D,E;
}

----未完，待续