黑马程序员---关于JAVA中JDK1.5新特性

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

"JDK1.5"一个重要的特征就是通过新增的一些特性来简化开发,这些特性包括有:泛型,for-each 循环,自动装包/拆包,枚举,可变参数,静态导入.使用这些特性 有助于我们编写更加清晰,,安全的代码.

1、泛型(Generic)

可以在编译的时候检测出类型错误，编译后和没有使用泛型的效果是相同的，但是使用泛型可以让你在编译时就发现错误.

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

public class GenericTest {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add(new Integer(1));
		c.add("123");
		for(Iterator<String> i=c.iterator();i.hasNext();){
			String s = i.next();
			System.out.println(s);
		}
	}
}

运行结果
D:\test>javac GenericTest.java
GenericTest.java:8: 无法将 java.util.Collection<java.lang.String> 中的 add(java.lang.String) 应用于 (java.lang.Integer)
                c.add(new Integer(1));
                 ^
1 错误

D:\test>

2.for-each(增强for循环)

语法:

 for(type 迭代变量名：集合变量名){…}

注意事项：

  ①  迭代变量必须在for()的括号内定义

  ②  集合变量可以是数组或者实现了Tterable接口的集合类

public class VariableParameter {
    public int add(int x,int...args)//args为可变参数变量名，可为任意变量名称
    {
       int sum=x;
       /*for(int i=0;i<args.length;i++)
       sum+=args[i];*/
       for(int arg:args)   //迭代变量arg可改为任意变量名称，如 a或b等
           sum+=arg;
       return sum;
    }
 
    public static void main(String[] args) {
       VariableParameter pv=new VariableParameter();
       System.out.println(pv.add(1, 2,3));
      
    	}	
 
}

}

3.自动装包/拆包(Autoboxing/unboxing)

　　自动装包/拆包大大方便了基本类型数据和它们包装类地使用.
　　自动装包:基本类型自动转为包装类.(int　>>　Integer)
　　自动拆包: 包装类自动转为基本类型.(Integer　>>　int)

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

自动装箱：

Integer iObj = 3; //将整数3赋给整数对象iObj,这样iObj对应的整数值就是3这利用的就是自动装箱技术，在jdk1.5之前,这是不行的,必须:Integer iObj=new Integer(3);

自动拆箱：

System.out.println(iObj + 12);//将Integer对象iObj对应的整数值直接与整数12相加，这利用的就是自动拆箱技术，这在jdk1.5之前是不行的，必须:iObj.intValue()+12

基本数据类型的对象缓存：

Integer num1=12;     

Integer num2=12;

System.out.println(num1==num2); 结果：true

Integer i1 = 137;

Integer i2 = 137;

System.out.println(i1 == i2); 结果：false

原因：

对于1个字节所能表示的所有整数即-128至127，在堆内存中都为它们创建了相应的对象，当程序中要为某个整数（范围在-128至127）创建多个对象时，这些对象的引用对应堆内存中的同一个地址，对象的引用都相等, 所以结果：true；对与超出1个字节表示范围的整数，在堆内存中并没有为它们创建相应的对象，所以当程序中要为某个整数（范围不在-128至127）创建多个对象时，它们在堆内存中会各自创建各自的对象。对象的引用指向不同的堆内存地址，所以结果为false

枚举

枚举：就是让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

package cn.itcast.Test;
import java.util.Date;
public class EnumTest {
    public static void main(String[] args) {
       WeekDay weekDay2 = WeekDay.FRI;
       System.out.println(weekDay2); //自动帮我们实现了toString，结果：FRI
       System.out.println(weekDay2.name());//结果:FRI
       System.out.println(weekDay2.ordinal());//排行第几从0开始，结果：5
    System.out.println(weekDay2.getClass());//得到自己的类，结果：WeekDay
    System.out.println(WeekDay.valueOf("SUN").toString());
System.out.println(WeekDay.values().length);/* WeekDay.values()返回一个包含WeekDay内所有成员变量的数组*/
 
    }
 
public enum WeekDay{ /*相当于一个内部类，等级和成员方法一样，所以其访问权限也和方法一样有4种public protected default private*/
SUN(1),MON(),TUE,WED,THI,FRI,SAT;/*枚举的值，相当于类的全局常对象，当类被调用时，其内部的全局常对象也会自动初始化，它们默认的是调用的类的无参构造函数。同样，当枚举WeekDay被调用时，枚举的值（它们本来就是全局常对象）也会初始化，默认调用的也是枚举的无参构造函数。而如果想让它们调用有参构造函数则需要在其后加上（参数值列表）。如果枚举内有方法，需放在值列表得后面且列表之后需加上；如果枚举内无方法，则值列表后可加；也可不加*/
private WeekDay(){System.out.println("first");}//构造方法必须是私有的
     private WeekDay(int day){System.out.println("second");}
    }
   
    public enum TrafficLamp{
       RED(30){
           public  TrafficLamp nextLamp(){
              return GREEN;
           }
       },
       GREEN(45){
           public  TrafficLamp nextLamp(){
              return YELLOW;
           }         
       },
       YELLOW(5){
           public  TrafficLamp nextLamp(){
              return RED;
           }         
       };
       public abstract TrafficLamp nextLamp();/*在枚举中定义了一个抽象方法则这个枚举也成为抽象的了，因为枚举本身就是类，所以它就不能再实例化，即new对象，而需要调用覆盖它所有抽象方法的子类去创建对象，因为值列表中的元素本身就是静态常对象，所以此时也不能像枚举WeekDay里面的值列表那样定义了，而需要在元素后面加上子类的类体，即创建匿名内置类对象*/
       @SuppressWarnings("unused")
       private int time;
       private TrafficLamp(int time){this.time = time;}
    }
}

 因为枚举本身就是类，所以它就不能再实例化，即new对象，而需要调用覆盖它所有抽象方法的子类去创建对象，因为值列表中的元素本身就是静态常对象，所以此时也不能像枚举WeekDay里面的值列表那样定义了，而需要在元素后面加上子类的类体，即创建匿名内置类对象.

如果枚举只有一个成员，可以作为一种单例实现方式。

可变参数

特点:只能出现在参数列表的最后；可变参数位于变量类型和变量名之间，前后有无空格都可以；调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数.

下面给出网上一个唐僧给悟空讲佛经的例子:

public class VarargsTest {
	public void speak(String name, Object... arguments) {
		System.out.print(name+": ");
		for (Object object : arguments) {
			System.out.print(object);
		}
		System.out.println();
	}

	public static void main(String[] args) {
		VarargsTest vt = new VarargsTest();
		vt.speak("悟空", "人和妖精都是妈生的,");
		vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");
	}
}

运行结果：
悟空: 人和妖精都是妈生的,
悟空: 不同的人是人他妈生的,妖是妖他妈生的,

静态导入

 import static 包类.类名.静态方法名;  例如 import static java.lang.Math.*;  

 如果在某一个类中导入了静态方法，那么在这个类中
 可以直接使用这个静态方法。而不需要去使用类名调用。

 使用静态导入弊端：如果出现重复的方法名，这时区分不开。
                   并且代码不方便阅读。

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