黑马程序员--JDK1.5 新特性总结

两个逻辑还都算通哈~ 第一个好些？

4 ：增强for
猪：注解
没：枚举
饭：泛型
竟：静态导入
装：装箱拆箱
渴(惨)：可变参数


本次介绍 枚举，静态导入，增强for，装箱拆箱，可变参数


一、装箱拆箱
Integer iobj=3;

jdk1.5之前上面这条语句是会报错的，那时定义是这样的 Integer iobj=new Integer(3);

现在可以直接这样了。Integer iobj=3;这就是装箱的过程

现在引入网上搜到的一条定义：

装箱：就是把原始类型用他们对应的引用类型包装起来。使他们具有引用的特性。

拆箱：就是把引用类型的数据简化成原始类型的数据

下面这个就是拆箱的过程

Integer []aint={1,2,4,5,6};
int sum=0;
for(int i=0;i<aint.length;i++)
{
sum+=aint[i];
}
System.out.println(sum);

这些动作都是自动的。

Integer有一个特点如下：

Integer i1=13;//-128~127 在一个字节之内的Integer 会使用同一片内存 超过这一范围，就使用不同的内存了
Integer i2=13;
Integer i3=137;
Integer i4=137;

System.out.println("i1=i2?:"+(i1==i2));
System.out.println("i3=i4?:"+(i3==i4));

结果：
i1=i2?:true
i3=i4?:false

i1和i2是相同，i3和i4却不相同。这也是自动装箱一个特点。其实在一个字节（也就是-128~127）之内的Integer 会使用同一片内存 超过这一范围，就使用不同的内存了
据老师所说，这个是OO中的享元模式，因为较小的数使用频率较高，就没必要再定义一片内存了。但是这只是针对装箱的哦，Integer i1=new Integer（13）;就不一样了，不管数字大小，都是两片内存了哦！


二、增强for循环
个人十分喜欢此功能。有的时候比迭代器简单多了。

String [] arr=new String[]{"zhang","li","wang","sun"};

for(String s:arr)

{

System.out.println(s);

}

但此方法也有限定，不能取原始类型的数组。但可以取他们对应的封装类型。

以下是语法

for(集合的元素类型：集合)

三、静态导入
比如我们常写的一个System.out.println这条语句 每次都要写好多呢吧。现在可以这样

import static java.lang.System.out;

out.println("aa");

out.println("bb");

import static java.lang.Math.max;

System.out.println(Math.max(13, 54));
System.out.println(Math.abs(3 - 6));
System.out.println(max(23, 34));//这条使用了静态导入

四、可变参数
可变参数的应用还是比较多的，看了很多jdk文档会发现有很多方法都添加了可变参数。

函数中的最后一个参数可以定义为可变参数。可以不固定长的参数。其底层实现原理其实是数组参数。因为jdk1.5之前想实现可变参数是要传入一个数组的

public static int add(int x,int ... args)
{
int sum=0;
sum+=x;
for (int i = 0; i < args.length; i++) {
sum+=args[i];

}
return sum;
}

public static void main(String[] args) {
System.out.println(add(4,5));
System.out.println(add(4,5,43,3));
System.out.println(add(4,5,43,3,34));
System.out.println(add(4,5,43,3,34,15));
}

可变参数注意事项：

可变参数只能是最后一个参数。

比如：public static int add(int ... args,int x)

上面这个函数会引起歧义，我如果传5个参数，编译器会以为这5个参数都是可变参数。

五、枚举类
如下代码

枚举类是一个特殊的类，先看一个小的枚举类

public enum Day

{

Mon,Tue,Wed,Tru,Fri,Sat,Sun;

}

这就是一个简单的枚举类，该类定义的时候就确定了固定的对象，该类可以有构造方法，对象可以传入构造参数，由于构造函数必须是私有的，所以枚举如果只有一个成员时，就可以作为一种单例的实现方式。调用类中的对象是 类名.对象 调用的如： Day.Sun;Day.Wed;等等

下面介绍一个交通灯的枚举类

public enum TrafficLamp{

RED(30)
{

public TrafficLamp nextLamp() {
return GREEN;
}

}
,GREEN(45){

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();

}

public static void main(String[] args) {
WeekDay weekDay=WeekDay.Mon;

System.out.println(weekDay.nextDay());

WeekDay1 day=WeekDay1.Fri;
System.out.println(day);
System.out.println(day.ordinal());

System.out.println(day.name());
System.out.println(day.toString());

System.out.println(WeekDay1.valueOf("Sun"));//把String类型转成WeekDay对象
System.out.println(WeekDay1.values());//返回数组~ 可以进一步操作

TrafficLamp ta=TrafficLamp.RED;
System.out.println(ta.nextLamp());
System.out.println(ta.time);
System.out.println(ta.nextLamp().time);


}

该类中的定义的一个抽象方法，每个对象都是用匿名类来实现的。该类的一个构造方法说明每个灯亮的时间。



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