java JDK1.5新特性(一) [静态导入] [可变参数] [增强for] [自动装箱拆箱] [枚举]

 

1. 静态导入 Static import
   1. 静态导入的优缺点
2. 可变参数 Varargs
   1. 可变参数的特点
   2. 方法使用可变参数重载
   3. 新特性的可变参数与旧版本的数组参数的兼容性
3. 增强for循环 forEnhance
   1. 增强for循环格式
   2. 增强for循环的优缺点
   3. 三种遍历方式
4. 自动装箱autoboxing拆箱unboxing  
   1. 享元设计模式
5. 枚举Enums
   1. 枚举类的特点 
   2. 枚举类
   3. Enum 类 

• 静态导入（Static import）

import static 包名.类名.*

类名后可以是通配符也可以是成员或静态方法名,字段,静态变量名

如通过

import static java.lang.Math.*;

则可以直接使用Math类下的方法或字段静态变量而不需要每次调用都要在前面加Math.来调用

静态导入的优缺点:

优点:

对某类进行静态导入之后,可以不需要每次调用该类静态方法或者字段静态属性时都要带上类名

在多次使用某个类的静态方法或字段时,可以简化输入操作

缺点:

阅读性变差 

当不同的类有相同的静态方法名或字段名时若同时进行静态导入使用时会出现混淆 , 例如

如果对Integer类和Long类执行了静态导入，引用MAX_VALUE将导致一个编译器错误，

因为Integer和Long都有一个MAX_VALUE常量，并且Java不会知道你在引用哪个MAX_VALUE。

• 可变参数(Varargs)

泛型是可变参数类型 而这里的可变参数是指可变参数个数

        可变参数的特点:

• • 一个方法只能有一个可变参数，并且这个可变参数必须出现在参数列表的最后  " 类型...args"

args为参数数组名,调用可变参数的方法时,编译器为可变参数隐含创建一个数组,在方法体中以数组形式访问可变参数

调用的时候可以指定任意个指定类型的参数,参数被存入名为args的数组中,方法体中可以对该数组进行操作

普通办法的"可变参数"

public class PrintArgs1 {
       static void printArray(Object[] args){
              for(Object obj:args)
                     System.out.print(obj+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              printArray(new Object[]{
                     new Integer(47),new Float(2.3),new Double(12.34)  
              });
	   }
}

JDK1.5的可变参数

public class PrintArgs2 {
       static void printArray(Object...args){
              for(Object obj:args)
                     System.out.print(obj+" ");
              System.out.println();
       }
 
       public static void main(String[] args){
              printArray(new Integer(47),new Float(3.14),new Double(11.11));
              printArray(new A(),new A(),new A());
              printArray();
       }
}

VarArgs1和VarArgs2的 printArray方法体都一样 , 但是
前者: 参数必须指明接收的参数类型为Object类或子类对象的数组 , 数组长度不定,可以在调用的时候确定,
而且在调用的时候就必须创建一个Object类数组对象 , 用创建的数组对象接收要操作的数据 , 再将
该数组传给调用函数
后者: 在参数列表中没有指明接收的是Object数组,只指明接收的是哪一类 , 但是调用的时候会自动产生一个
Object类数组进行接收参数,参数个数可以在调用时确定,




        

方法使用可变参数重载

        方法重载中使用参数列表使用可变参数时,那么调用时会自动匹配一个最佳方法进行调用;
重载中多个方法都匹配时优先使用定长参数的方法;

重载中不能同时存在如下形式

public void method1(Object... arg1){};  

public void method1(Object[] arg1){};

两种形式被认为是重复的 , 可以看出前者调用的时候跟后者一样,只不过后者是认为创建数组,前者是自动产生的

public void method1(Object... arg1){};

等效于  

public void method1(T... arg1){};  

以下重载方法

0) static void printArray(Integer q,Integer t){}

1) static void method(Byte...args){}

2) static void method(Short...args){}

3) static void method(Character...args){}

4) static void method(Integer...args){}

5) static void method(Long...args){}

6) static void method(Float...args){}

7) static void method(Double...args){}

8) static void method(String...args){}

9) static void method(Object...args){}或static void method(T...args){}

对重载方法的调用

method(12,42);//调用0)的method

method(12,42,44,77);//调用4)的method

method(42,244444234,423432424);//调用4)的method

method(42L,244444234L,423432424L);//调用5)的method

method(23,123,0);//调用4)的method

method((byte)23,(byte)123,(byte)0);//调用1)的method

method("安","fe","和");//调用8)的method

method('v','a','4','a');//调用3)的method

method(2.4,5,'f',"fe");//调用9)的method

method(2.4,5,'f',"fe",new Object());//调用9)的method

整型参数如果没有强制转换则默认匹配的只有Integer类型的方法或Object类型或泛型方法 , 

但同时存在时优先调用Integer类的参数的方法 

字符串型实参只匹配String类变长参数方法或Object类或泛型,同时存在是只会调用String类参数方法

字符型也一样优先调用Character类参数方法

新特性的可变参数与旧版本的数组参数的兼容性

        将一个数组的实际参数传递给一个在

JDK1.5以前属于数组构成的形式参数

JDK1.5后属于可变参数的形式参数的方法时

对于能兼容JDK1.5以前方式的会直接用以前的方式接受参数

对于不能兼容的以前方式的会用JDK1.5出现的可变参数方式将传入的

数组解包,将每个数组元素传给可变参数

int[] i = {1,3,5};

Integer[] j = {1,3,5};

String[] sts = {"f","fe","fee"};

/*传入int数组,因为int不是引用类,只有int[]才是引用类,数组中的int元素

不能当做集合的元素存入到集合中,即不兼容旧的数组形式的版本,

不能按照数组方式传入,只能按可变参数的一个参数传入,所以返回的集

合中只有一个元素,即数组引用i本身*/

System.out.println(Arrays.asList(i));

/*Integer数组元素是引用类型可以被集合接收,所以j被当做数组传入,

传入时,将拆散数组元素将元素装入集合*/

System.out.println(Arrays.asList(j));

/*传入的String数组,因为String就是Object类,所以传入的数组参数被

拆开,兼容旧版本按照数组参数方式来处理 , 所以返回的集合中存入被打散

的String数组的元素*/

System.out.println(Arrays.asList(sts));

System.out.println(Arrays.asList(1,3,5));//按可变参数传入

System.out.println(Arrays.asList("f","fe","fee"));//按可变参数传入

System.out.println("["+Arrays.asList(i).get(0)[0]+", "+

Arrays.asList(i).get(0)[1]+", "+

Arrays.asList(i).get(0)[2]+"]");

打印结果为   

[[I@1cf8583]

[2, 4, 6]

[f, fe, fee]

[1, 3, 5]

[f, fe, fee]

[1, 3, 5]

• 增强for循环 forEnhance

增强for循环格式

for(Type 变量名 : 该类型的数组\集合容器){...}

集合容器可以是数组或实现了Iterable接口的集合

增强for循环的优缺点

优点: 与传统for循环比较大大简化了代码

缺点: 不能根据数组或有序集合元素索引来操作元素

三种遍历方式

1 普通for遍历           

2 增强型for遍历

for(元素类型 元素变量:集合/数组)

2.1--遍历数组

int [] arr ={1,3,5,6};

for(int i:arr){...}

int[][] arrs = {{1,4,7},{2,6,7,4}};

for(int[] r : arrs)

{

for(int e:r)

{

...

}

...

}

2.2---遍历集合

增强型for循环优点主要表现在集合的遍历上,利用了集合的泛型特性

局限性:

不能利用数组或有序集合的索引的进行判断删除元素等操作,

不能对集合本身进行操作

底层原理还是迭代器 如:

ArrayList list = new ArrayList();  

for (Integer i : list) { ... }

实际是以下for的简化写法

ArrayList list = new ArrayList();

for (Iterator  i = list.iterator(); i.hasNext();) {

Integer value=i.next();

}

3, 迭代遍历

                       迭代法是集合提供的一种遍历方法,适用于任何一个类

Set set = new HashSet();
Iterator it = set.iterator(); 
while (it.hasNext()) 
{  
String str = it.next();  
System.out.println(str); 
}

自定义实现了Iteratle接口的类 , 使该类能用增强for来遍历

import java.util.Iterator;


public class Container implements Iterable {
	protected T[] elements;
	public Container(T... elems) {
		this.elements=elems;
	}
	public Iterator iterator() {//实现Iterable接口下的 iterator方法
		return new Iterator(){//匿名内部类实现 Iterator 接口覆盖三个方法
			private int index = elements.length-1;
			public boolean hasNext() {
				return index > -1;
			}


			public T next() {
				return elements[index--];
			}
			
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}
	
	public static void main(String[] args)
	{
		Container