黑马程序员_高新技术:JDK1.5新特性

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、静态导入

1、概述

import 语句从根本上来说唯一有价值的是减少了击键次数，使代码更易于阅读。在JAVA 5中，新增加了一个特性静态导入 ( static import ) ，当希望使用类的静态成员时，就可以使用静态导入。

2、格式：

 import staticjava.util.Math.*; //导入Math这个类中的所有静态成员。

3、注意：

(1)、 当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

(2)、当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。

4、示例：

<span style="font-size:18px;">import static java.lang.System.*;

class  Test 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");	//不加静态导入时需要在out前加上System.

		out.println("Hello World!");//加入静态导入后，打印输出时就可以直接省略书写System.
		
	}
}
</span>

二、泛型：

1、概述：

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法 2、好处：

(1)、将运行时期出现的问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少、安全。

(2)、避免了强制转换的麻烦。

3、格式：

       通过<>来定义要操作的引用数据类型

      如：ArrayList<String>  //定义要存入集合中的元素指定为String类型

4、注意：

(1)、泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，

对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。//因此可以用反射的方法往其中加入泛型限定外的对象。

(2)、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。

5、什么时候写泛型？

        通常在集合框架中很常见，只要见到API文档上的<>就要定义泛型。

        其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

5、示例：

<span style="font-size:18px;">public class MapList {
	public static void main(String[] args) {
		//Map集合中存储的是键值对，所以要定义的泛型也需要指明键值对的数据类型。
		Map<String,Integer> map = new TreeMap<String,Integer>();
		
		map.put("2", 20);
		map.put("3", 30);
		map.put("4", 40);
		
		Collection<Integer> coll = map.values();	//值为Integer类型的，所以该泛型也要接收Integer的类型
		
		System.out.println(coll);
		
	}
}</span>

6、通配符<?>

1、

当传入的类型不确定时，可以使用通配符？。也可以理解为占位符。使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩张性。

示例：

Collection<?>  a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以：a=newArrayList<Integer>和a=new ArrayList<String>都可以。

2、

        使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

7、泛型限定：

对于一个范围内的一类事物，可以通过泛型限定的方式定义，有两种方式：

       (1）? extends E：可接收E类型或E类型的子类型；称之为上限。

        示例：ArrayList<? extends Number>x = new ArrayList<Integer>();

       ( 2）? super E：可接收E类型或E类型的父类型；称之为下限。

        示例：ArrayList<? super Integer>x = new ArrayList<Number>();

8、自定义泛型

若类实例对象中要使用到同一泛型参数，即这些地方引用类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义。

示例：

<span style="font-size:18px;">class Gen<T> {
			private T ob; //定义泛型成员变量
			public Gen(T ob) {
				this.ob = ob;
				}
			public T getOb() {
				return ob;
				}
			public void setOb(T ob) {
				this.ob = ob;
				}
			public void showType() {
				System.out.println("T的实际类型是: " + ob.getClass().getName());
				}
			}</span>

三、增强for循环

1、格式：

        for(数据类型变量名 :被遍历的集合（collection）或者数组)

{

执行语句

}

2、for循环与迭代器的区别：

        (1)、for循环对集合进行遍历，只能获取集合元素。但是不能对集合进行操作。可以看作是迭代器的简写形式。

        (2)、迭代器除了遍历，还可以进行remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

3、传统for和高级for的区别：

       高级for有一个局限性。必须有被遍历的目标（集合或数组）。

       传统for遍历数组时有索引。

建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

注意：变量类型前可加修饰符，如final（可被局部内部类访问到）。

4、示例：

<span style="font-size:18px;">Set<Integer> keySet = map.keySet();
		for(Integer i : keySet)
		{
			System.out.println(i+"::"+map.get(i));
		}

		
		for(Map.Entry<Integer,String> entry : hm.entrySet())
		{
			System.out.println(entry.getKey()+"------"+entry.getValue());
		}</span>

四、可变参数：

1、概述

可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

2、格式：

public static void show(String str,int... arr)   //用…这三个点表示，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

示例：

<span style="font-size:18px;">public class VariableParameter {

	/**
	 * @param args
	 * 可变参数的使用。
	 */
	public static void main(String[] args) {
		
		System.out.println(add(2,3,5));
	}
	public static int add(int ... args)	//定义一个可变参数，可以将该参数看成一个数组来获取里面的值。
	{
		int sum = 0;
		for(int arg : args)
		{
			sum+=arg;
		}
		return sum;
	}
}
</span>

3、注意;

可变参数一定要定义在参数列表的最后面。

五、基本数据类型的自动装箱与拆箱：

1、对于基本数据类型的说明：整数在-128 ~ 127之间的数，包装成Integer类型对象，会存入常量池中的缓存，再创建一个对象的时候，如果其值在这个范围内，就会直接到常量池中寻找(享元设计模式)

示例：

<span style="font-size:18px;">//在-128~127 之外的数
 Integer i1 = 200;  
 Integer i2 = 200;          
 System.out.println("i1==i2: "+(i1==i2));       //打印结果为false            
 // 在-128~127 之内的数
 Integer i3 = 100;  
 Integer i4 = 100;  
 System.out.println("i3==i4: "+(i3==i4));	//打印结果为true</span>

2、自动装箱：Integer i = 100; //相当于编译器自动为您作以下的语法编译：Integer i = new Integer(100);

3、自动拆箱：int t = i; //将对象中的基本数据从对象中自动取出

六、枚举：

1、应用：

在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场，枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值。

示例：

<span style="font-size:18px;">public enum WeekDay
	{
		SUN(2),MON(),TUE,WES,THI,FRI,STA;	//这些对象只能放在第一行,在对象后面加(参数)表示调用不同构造函数
		private WeekDay(){System.out.println("first");};			//构造函数必须是私有的
		private WeekDay(int x){System.out.println("second");};			//构造函数必须是私有的
		
		
	}</span>

2、枚举使用注意：

(1)、构造器：

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

        2）构造器只有私有private，绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例。因为枚举值是public static final的常量，但是枚举类的方法和数据域是可以被外部访问的。

        3）构造器可以有多个，调用哪个即初始化相应的值。

(2)、非静态方法：（所有的枚举类都继承了Enum方法）

        1）String toString() ;//返回枚举量的名称

        2）int ordinal() ;//返回枚举值在枚举类中的顺序，按定义的顺序排

        3）Class getClass() ;//获取对应的类名

        4) String name();//返回此枚举常量的名称，在其枚举声明中对其进行声明。

(3)、静态方法：

        1）valueOf(String e) ;//转为对应的枚举对象，即将字符串转为对象

        2）values() ;//获取所有的枚举对象元素

3、枚举在匿名内部类的应用：

<span style="font-size:18px;">public class EnumTest {
	public enum TrafficLamp{
		RED(30){
			public TrafficLamp nextLamp(){
				return GREEN;
			}
		},
		GREEN(30){
			public TrafficLamp nextLamp(){
				return YELLOW;
			}
		},
		YELLOW(5){
			public TrafficLamp nextLamp(){
				return RED;
			}
		};
		private int time;
		
		private TrafficLamp(int time){
			this.time=time;}
		
		public abstract TrafficLamp nextLamp();
	}		
}
</span>

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------