------- Windows Phone 7手机开发、.Net培训、期待与您交流! -------
javaJDK1.5新特性介绍:
1.增强for循环(Enhanced For loop)--减少迭代器(iterator)的潜在错误(error-proneness)
语法:for(type 变量名:集合变量名){...}
注意事项:迭代变量必须在for()的括号内定义,集合变量可以是数组或者实现了Iterable接口的集合类。
package test;
public class VarableParameter {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(add(1));
System.out.println(add(1,2));
System.out.println(add(1,2,3));
System.out.println(add(1,2,3,4));
}
public static int add(int x,int ... args){
// for(int i=0;i<args.length;i++){
// x=x+args[i];
// }
for(int arg:args){
x=x+arg;
}
return x;
}
}
2.泛型(Generics)--为集合(collections)提供编译时类型安全,无需每刻从Collections取得一个对象就进行强制转换(cast)
在javaJDK1.5以前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的类型转换,而这种转换是要求开发者对实际类型参数了解的情况下进行的。对于强制类型转换,编译期间编译器并不会提示,只有在运行中才会出现异常,这是一个安全隐患。
泛型的规则和限制:
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());
}
}
public class GenDemo {
public static void main(String[] args){
//定义泛型类Gen的一个Integer版本
Gen<Integer> intOb=new Gen<Integer>(88);
intOb.showType();
int i= intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
//定义泛型类Gen的一个String版本
Gen<String> strOb=new Gen<String>("Hello Gen!");
strOb.showType();
String s=strOb.getOb();
System.out.println("value= " + s);
}
}
例2.没有使用泛型
class Gen2 {
private Object ob; //定义一个通用类型成员
public Gen2(Object ob) {
this.ob = ob;
}
public Object getOb() {
return ob;
}
public void setOb(Object ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class GenDemo2 {
public static void main(String[] args) {
//定义类Gen2的一个Integer版本
Gen2 intOb = new Gen2(new Integer(88));
intOb.showTyep();
int i = (Integer) intOb.getOb();
System.out.println("value= " + i);
System.out.println("---------------------------------");
//定义类Gen2的一个String版本
Gen2 strOb = new Gen2("Hello Gen!");
strOb.showTyep();
String s = (String) strOb.getOb();
System.out.println("value= " + s);
}
}
3。静态导入(static import ) :这一新特性使我们在写代码的时候更加简洁易读,无需在使用其他类的静态成员或方法时加上类名为前缀,如下代码。
package test;
public class Test {
public static void main(String[] args) {
System.out.println(Math.abs(3 - 6));
System.out.println( Math.max(1,4 ));
}
}
新特性后,使用import static 导入类的静态方法,即可在后续代码中省略类的后缀。
package test;
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
System.out.println(abs(3 - 6));
System.out.println(max(1,4 ));
}
}
4.可变参数(Var args):可变的参数只能出现在方法参数列表的最后。“...”位于变量类型和变量名之间,前后有无空格都行,调用可变参数方法时,编译器为该可变参数隐含创建一个数组,正方法体中以数组的形式访问可变参数。
package test;
public class VarableParameter {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(add(1));
System.out.println(add(1,2));
System.out.println(add(1,2,3));
System.out.println(add(1,2,3,4));
}
public static int add(int x,int ... args){
for(int i=0;i<args.length;i++){
x=x+args[i];
}
return x;
}
}
在调用可变参数方法的时候,可变参数的可以是0个参数,也可以是1个以上的参数。
5.自动装箱/自动拆箱
自动装箱:Integer num1=12;
这里的int类型的12被封装成了一个Integer对象。
自动拆墙:System.out.println(num1+12);
num1为Integer对象,对象不支持加法,这里java把num1转换成了int基本数据。
特别注意:Integer num1=12;
Integer num2=12;
这俩个对象num1和num2指向的是一个对象。他们相等,num1==num2 true;
-128-127这个范围内相同的俩个数包装为俩个Integer对象,那么这俩个对象相等。
6.枚举
1.为什么要有枚举?
问题:要定义星期几或性别变量时,该如何定义?建设分别用1-7分别来表示星期一到星期日,但有人可能会写成int weekday=0;
枚举就是要让某个类型的变量值只能为若干个固定值中的一个,否则,编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中的非法值,普通变量的方式在开发阶段无法实现这一目标。
/*
* 用普通类如何实现枚举功能,定义一个Weekday的类来模拟枚举功能。
1、私有的构造方法
2、每个元素分别用一个公有的静态成员变量表示
3、可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
*/
package cn.itheima;
public abstract class WeekDay {
private WeekDay(){}
public final static WeekDay SUN=new WeekDay(){
public WeekDay nextDay(){
return MON;
}
};
public final static WeekDay MON=new WeekDay(){
public WeekDay nextDay(){
return SUN;
}
};
public abstract WeekDay nextDay();
public String toString(){
return this==SUN?"SUM":"MON";
}
}
2、枚举的基本应用
通过enum关键字定义枚举类,枚举类是一个特殊的类,每个元素都是该类的一个实例对象。
用枚举类规定值,如上面的WeekDay类。以后用此类型定义的值只能是这个类中规定好的那些值,若不是这些值,编译器不会通过。
好处:在编译时期就会发现错误,表明值不符合,减少了运行时期的错误。
如果调用者想打印枚举类中元素的信息,需由编写此类的人定义toString方法。
注:枚举类是一个class,而且是一个不可被继承的final类,其中的元素都是类静态常量。
常用方法:
构造器:
构造器只是在构造枚举值的时候被调用。
构造器只有私有private,绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例。因为枚举值是public static final的常量,但是枚举类的方法和数据域是可以被外部访问的。
构造器可以有多个,调用哪个即初始化相应的值。
非静态方法:(所有的枚举类都继承了Enum方法)
String toString() ;//返回枚举量的名称
int ordinal() ;//返回枚举值在枚举类中的顺序,按定义的顺序排
3)Class getClass() ;//获取对应的类名
4) String name();//返回此枚举常量的名称,在其枚举声明中对其进行声明。
静态方法:
valueOf(String e) ;//转为对应的枚举对象,即将字符串转为对象
values() ;//获取所有的枚举对象元素
示例:
package cn.itheima;
public class EnumDemo {
public static void main(String[] args) {
WeekDay weekDay=WeekDay.MON;
System.out.println(weekDay);//输出枚举常量名
System.out.println(weekDay.name());//输出对象名
System.out.println(weekDay.getClass());//输出对应类
System.out.println(weekDay.toString());//输出枚举对象名
System.out.println(weekDay.ordinal());//输出此对象在枚举常量的次序
System.out.println(WeekDay.valueOf("WED"));//将字符串转化为枚举常量
System.out.println(WeekDay.values().length);//获取所以的枚举元素,并打印其长度
}
//定义枚举内部类
public enum WeekDay{
SUN(1),MON,TUE,WED,THI,FRI,SAT;//分号可有可无,但如果下面还有方法或其他成员时,分号不能省。
//而且当有其他方法时,必须在这些枚举变量的下方。
//无参构造器
private WeekDay(){
System.out.println("First");
}
//带参数的构造器
private WeekDay(int day){
System.out.println("Second");
}
}
}
3、枚举的高级应用
枚举就相当于一个类,其中也可以定义构造方法、成员变量、普通方法和抽象方法。
枚举元素必须位于枚举体中的最开始部分,枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面,编译器报告错误。
带构造方法的枚举
构造方法必须定义成私有的
如果有多个构造方法,该如何选择哪个构造方法?
枚举元素MON和MON()的效果一样,都是调用默认的构造方法。
4、带方法的枚举
如:
/*
* 抽象的枚举方法
* 此时枚举中的常量需要子类来实现,这是可以利用内部类的方式来定义枚举常量
* 带方法的枚举
1)定义枚举TrafficLamp
2)实现普通的next方法
3)实现抽象的next方法:每个元素分别是由枚举类的子类来生成的实例对象,这些子类
4)用类似内部类的方式进行定义。
5)增加上表示时间的构造方法
* */
package cn.itheima;
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();
}
}
小结:
匿名内部类比较常用
类的方法返回的类型可以是本类的类型
类中可定义静态常量,常量的结果就是自己这个类型的实例对象
枚举只有一个成员时,就可以作为一种单例的实现方式。
注:
所有的枚举都继承自java.lang.Enum类。由于Java不支持多继承,所以枚举对象不能再继承其他类。
switch语句支持int,char,enum类型,使用枚举,能让我们的代码可读性更强。
------- Windows Phone 7手机开发、.Net培训、期待与您交流! -------