静态导入,可变参数,枚举与增强型for循环

关于Java基础的文章，我觉得写得还可以，以前发在了我其它的博客了，肯定是原创，现在再分享给大家出来。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 一、概述

其实说起来jdk1.5已经出现很长时间了，现在再说它是新特性未免有些过时，事实上这一部分知识从新颖性上确实不足，但是从实用性上却是值得我们好好研究。

些特性包括静态导入、可变参数、增强形for循环、自动拆箱与装箱、枚举、反射、javaBean内省。

那么之后就依次介绍这些新特性。

 二、静态导入

·1，语法

静态导入的知识比较简单，就是在导入包的语句中的import关键字后面加static关键字。

比如：import static java.lang.Math.PI;

a，以前没有静态导入的时候写法

System.out.println(Math.random());

b，有静态导入的写法

import static java.lang.Math.PI;
import static java.lang.Math.random;
public class TextDemo {
	public static void main(String[] args) {
		System.out.println(PI);
		System.out.println(random());
	}
}

2，优缺点

静态导入虽然简化了我们的书写，但也容易造成不必要的混淆。因为看不到方法的所属，而且也不能导入不同包中相同名称的方法，所以并不推荐大量使用静态导入。

 三、可变参数

1，概述

可变参数顾名思义，就是使程序员可以声明一个接受可变数目参数的方法。

比如说我们要做一个简单的加法函数

add(1,2)

add(1,2,3)

add(1,2,3,4)

add(1,2,3,4,5)

因为这个方法接受的参数个数不确定，按照我们以前的做法要写很多个方法重载来完成，显然很麻烦。如果使用可变参数的话我们只需要一个函数就行了

2，例如

public class TextDemo {
	public static void main(String[] args) {

		System.out.println(add(1, 2));
		System.out.println(add(1, 2, 3));
		System.out.println(add(1, 2, 3, 4));
		System.out.println(add(1, 2, 3, 4, 5));
	}

	
	private static int add(int i, int ... nums) {
		int sum = i;
		for(int num : nums){
			sum =sum + num;
		}
		return sum;
	}
}

,3，注意：

a，可变参数只能出现在参数列表的最后

b，...位于类型和变量之间，有无空格均可。

c，根据如下代码提示可以看出，int ... nums 其实隐含的是声明了一个数组。

 四、增强型for循环

增强型for循环在上个例子中其实就已经用到了，事实上它也确实挺好用的。

1，语法

for(数据类型变量名 :被遍历的集合或者数组) {...}

2，举例

上面有一个迭代数组的例子，这里就再举一个集合的吧

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

public class TextDemo {
	public static void main(String[] args) {
		ArrayList<String> arrs = new ArrayList<String>();
		arrs.add("aaa");
		arrs.add("bbb");
		arrs.add("ccc");
		
		//传统迭代方法
		Iterator it = arrs.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		//增强for循环迭代方式
		for(String arr : arrs){
			System.out.println(arr);
		}
	}	
}

3，注意

增强型for循环对集合进行遍历，只能获取集合元素。但是不能对集合进行操作。

传统for遍历数组时有索引，如果想要对某一索引操作还是需要用传统for循环。

 五、自动拆箱与装箱

在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

自动装箱：基本类型自动转为包装类.(int >> Integer)

自动拆箱：包装类自动转为基本类型.(Integer >> int)

public class TextDemo {
	public static void main(String[] args) {
		int i = 2;
		ArrayList<Integer> arrs = new ArrayList<Integer>();
		arrs.add(i);//自动装箱，自动将int转换成Integer
		
		//-------------------------------------------\\
		Integer j = 3;
		int num = 2 + j;//自动拆箱，将Integer自动转成int
	}	
}

 六、枚举

1，概述

用过c++的人肯定对枚举不陌生，现在java也加入了枚举。

枚举作用就是让某个类型的变量取值只能为若干固定的值，否则，编译器就会报错。

枚举可以让编译器在编译时就能控制源程序中填写的非法值。

2，格式

public　enum　weeks
{
　　　SUN, MON, TUE, WEN, THI, FRI, SAT;
}

3，常见方法

		weeks day = weeks.MON;
		System.out.println(day);
		System.out.println(day.name());
		System.out.println(day.toString());
		System.out.println(weeks.FRI);
		System.out.println(day.ordinal());//该元素在所属的位置
		System.out.println(day.valueOf("FRI"));//将字符串转化为枚举常量  
		System.out.println(day.values().length);//获取长度

,4，带有构造函数方法的枚举

枚举可以看做一个内部类，类有构造方法，枚举也不例外

5，注意：

a，但是枚举的构造只能私有，不能公有，因为枚举值是public static final的常量，这样可以保证外部代码无法重新构造枚举类的实例。

b，构造器只是在构造枚举值的时候被调用。

比如：

<span style="white-space:pre">	</span>public static void main(String[] args) {
<span style="white-space:pre">		</span>weeks day = weeks.MON;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>public enum weeks {// 这里的枚举是一个内部类
<span style="white-space:pre">		</span>SUN, MON, TUE, WEN, THI(1), FRI, SAT;//这里的THI(1)就是在调用枚举的有参构造函数
<span style="white-space:pre">		</span>private weeks() {
<span style="white-space:pre">			</span>System.out.println("first");
<span style="white-space:pre">		</span>}


<span style="white-space:pre">		</span>private weeks(int i) {
<span style="white-space:pre">			</span>System.out.println("second");
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}

返回的结果调用了7此构造函数

6，带有方法的枚举

public class TextDemo {
	public static void main(String[] args) {
		TrafficLamp lamp =TrafficLamp.Red;
		System.out.println(lamp.nextLamp().toString());
	}	
	
	// 交通灯
	public enum TrafficLamp {
		Red,Yello,Green;

		public  TrafficLamp nextLamp() {
			if (this == Yello) {
				return Red;
			}
			if (this == Red) {
				return Green;
			}
			if (this == Green) {
				return Yello;
			}
			return null;
		}

	}
}

7，带有抽象方法的枚举

// 交通灯
	public enum TrafficLamp {
		Red(60){//内部类中的匿名内部类,表示红灯60s
			@Override
			public TrafficLamp nextLamp() {
				
				return Green;
				
			}
			
		},Yello(10) {
			@Override
			public TrafficLamp nextLamp() {
				
				return Red;
				
			}
		},Green(60) {
			@Override
			public TrafficLamp nextLamp() {
				
				return Yello;
				
			}
		};

		public abstract TrafficLamp nextLamp();

		private int time;
		private TrafficLamp(int time) {
			this.time = time;
		}
	}

 七、最后

JDK1.5的新特性，都是与我们实际开发有关的有用功能，由于篇幅有限，所以写成多篇。