黑马程序员——JDK5.0新特性

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

现在首先摘录一部分网上的总结，自己会在下面加上自己写的例子。

1.泛型(Generic)
　　C++通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

2.For-Each循环
　　For-Each循环得加入简化了集合的遍历。

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

4.枚举(Enums)
　　JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu.　我们可以这样来定义一个枚举类型。　
public　enum　Color
{
　　　Red,
　　　White,
　　　Blue
}

　　然后可以这样来使用Color　myColor　=　Color.Red.
　　枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如
for　(Color　c　:　Color.values())
　　　　　　　　　　　　System.out.println©;

　　5.可变参数(Varargs)
　　可变参数使程序员可以声明一个接受可变数目参数的方法。注意，可变参数必须是函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象，
util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…
　　在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了
public　void　write(Object...　objs)　{
　　　for　(Object　obj:　objs)
　　　　　　System.out.println(obj);
}
　　在引入可变参数以后，Java的反射包也更加方便使用了。对于c.getMethod("test",　new　Object[0]).invoke(c.newInstance(),　new　Object[0]))，现在我们可以这样写了c.getMethod("test").invoke(c.newInstance())，这样的代码比原来清楚了很多。　

6.静态导入(Static　Imports)
　　要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
import　static　java.lang.Math.*;
…….
r　=　sin(PI　*　2);　//无需再写r　=　Math.sin(Math.PI);
　　不过，过度使用这个特性也会一定程度上降低代码地可读性。

 7.注解

非常重要
Annotation 注解
@SuppressWarnings
指示应该在注释元素(以及包含在该注释元素中的所有程序元素)中取消显示指定的编译警告
@Deprecated
在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告
@Override
表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注释但没有重写超类方法，则编译器会生成一条错误信息。
注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记。没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上
看java.lang包，可以看到JDK中提供的最基本的annotiation
注解的应用结构图
注解类---->应用了“注解类”的类----->对“应用了注解类的类”进行反射操作的类
注解类就相当于一个你的源程序中要调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。就想你要调用某个类，得先有开发好这个类。
@Retention元注解 标注注解的生命周期
RetetionPolicy.SOURCE,RetetionPolicy.CLASS,RetetionPolicy.RUNTIME分别对应源文件，class文件，内存中的字节码
@Target 表示注解的作用域
Interface Type 1.5 新东西
注解的属性
数组类型的属性
int[] arrayAttr() default{1,2,3};
@MyAnnotation(arrayAttr={2,3,4});
如果数组属性中只有一个元素，这时属性值部分可以声落大括号
枚举类型的属性
EnumTest.TrafficLamp lamp();
@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN);
注解类型的属性
MetaAnnotation annotationAttr() default @MetaAnnotation("xxxx");
@MyAnnotation(annotationAttr=@MetaAbbotation("yyy"));
可以认为上面这个@MyAnnotation是MyAnnotation类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象。 

8.

java.lang.reflect
接口 Type

public interface Type

Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

 

 

 

//静态导入，导入某个类中的所有静态方法。
//JDK1.5新特性，注意语法
import static java.lang.Math.*;


public class StaticDemo {
	public static void main(String[] args) {
		System.out.println("hello world!");
		for(int i=0;i<3;i++){
			i = i+1;
			System.out.println(i);
		}
		System.out.println(round(10.5));
		System.out.println(max(3, 6));
		System.out.println(min(9, 8));
		System.out.println(abs(3 - 7));
	}

}

 

package cn.heima;
//可变参数
//高级for循环
public class VariableParameter {
	public static void main(String[] args) {
//		System.out.println("hello java");
		System.out.println(add(1,2,3));
		System.out.println(add(1,2,3,4,5));
		
	}
	//调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在
	//方法体内以数组的形式访问可变参数。
	public static int add(int x,int... args){
		int sum = x;
		//既然是数组，直接用高级for，测试果然有效，一个例子包含两个新特性讲解O(∩_∩)O~
		for(int arg:args){
			sum+=arg;
		}
		return sum;
		/*for(int i=0;i<args.length;i++){
			sum+=args[i];
		}
		return sum;
		*/
	}
}

package cn.heima;
//自动拆箱装箱的原理，享元模式，flyweight
public class AutoBox {
	public static void main(String[] args) {
		String  s1 = new String("abc");
		String  s2 = new String("abc");
		//false 两个对象
		System.out.println(s1==s2);
		Integer i1 = 12;
		Integer i2 = 12;
		//自动装箱true
		System.out.println(i1==i2);
		//自动拆箱，Integer本身没有加法，不能相加
		System.out.println(i1+15);
		Integer i3 = new Integer(13);
		Integer i4 = new Integer(13);
		//堆内存新建两个对象false
		System.out.println(i3==i4);
		Integer i5 = Integer.valueOf(20);
		Integer i6 = Integer.valueOf(20);
		//true
		System.out.println(i5==i6);
		Integer i7 = Integer.valueOf(200);
		Integer i8 = Integer.valueOf(200);
		//false
		System.out.println(i7==i8);
	}

}

 

 

package cn.heima;

abstract class WeekDay {
	private WeekDay(){}
	//在本类内部定义好对象，匿名内部类
	public final static WeekDay SUN = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return MON;
		}
	};
	public final static WeekDay MON = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return TUE;
		}
	};
	public final static WeekDay TUE = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return WED;
		}
	};
	public final static WeekDay WED = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return THU;
		}
	};
	public final static WeekDay THU = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return FRI;
		}
	};
	public final static WeekDay FRI = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return SAT;
		}
	};
	public final static WeekDay SAT = new WeekDay(){
		@Override
		public WeekDay nextDay() {
			return SUN;
		}
	};
	
	//采用抽象方法定义nextDay，就将大量的if...else语句转移成了一个独立的类
	public abstract WeekDay nextDay();
	
	//方法极其啰嗦，代码冗余。
/*	public WeekDay nextDay(){
		if(this==SUN){
			return MON;
		}
		else if(this == MON){
			return TUE;
		}
		else if(this==TUE){
			return WED;
		}
		else if(this==WED){
			return THU;
		}
		else if(this==THU){
			return FRI;
		}
		else if(this==FRI){
			return SAT;
		}
		else{
			return SUN;
		}
	}*/
	public String toString(){
		if(this==SUN) 
			return "星期日";
		if(this==MON)
			return "星期一";
		if(this==TUE)
			return "星期二";
		if(this==WED)
			return "星期三";
		if(this==THU)
			return "星期四";
		if(this==FRI)
			return "星期五";
		if(this==SAT)
			return "星期六";
	return null;
	}

}

 

package cn.heima;

public class Enum {
	public static void main(String[] args) {
		WeekDay1 wd = WeekDay1.SUN;
		System.out.println(wd.nextDay());
		WeekDay1 wd1 = WeekDay1.MON;
		System.out.println(wd1.nextDay());
		WeekDay wd3 = WeekDay.MON;
		
		System.out.println(wd3);
		//传递一个字符串返回一个枚举对象。
		System.out.println(WeekDay.valueOf("SAT"));
		System.out.println(WeekDay.valueOf("SUN"));
		//返回数组
		WeekDay[] wds = WeekDay.values();
		//ordinal(),排名
		for(WeekDay wday:wds){
			System.out.println(wday.name()+"---"+wday.ordinal());
		}
	}
	public enum WeekDay{
		SUN,MON,TUE,WED,THU,FRI,SAT;
	}
}

 

 

public enum TrafficLamp{

                  //{}用于实现抽象方法，()表示是用的带参数的构造函数创建的
		GREEN(50){
			public TrafficLamp nextLamp(){
				return YELLOW;
			}
		},
		RED(30){
			public TrafficLamp nextLamp(){
				return GREEN;
			}
			
		},
		YELLOW(5){
			public TrafficLamp nextLamp(){
				return RED;
			}
		};
		private int time;

                  //定义带参数的构造函数
		private TrafficLamp(int time){
			this.time = time;
			
		}

                  //定义抽象方法
		public abstract TrafficLamp nextLamp();
	}

 

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//注解保留到运行时期
@Retention(RetentionPolicy.RUNTIME)
//可以放在哪里
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface HeiMaAnnotation {
	String color() default "yellow";
	String value() ;
	int[] arr() default {1,2,3};
	String[] arrs() default{"haha"};
	Enum.TrafficLamp lamp() default Enum.TrafficLamp.RED;
	MyAnnotation annotatioArr() default @MyAnnotation("bxd");
	Class claz() default int.class;

}

import java.lang.annotation.Annotation;
import java.util.Arrays;

@HeiMaAnnotation(color="red",value="testing" ,arr={1},arrs={"annotation","struts2"},
annotatioArr=@MyAnnotation("laobi"),lamp=Enum.TrafficLamp.YELLOW,claz=String.class)
public class AnnotationTest {
	@HeiMaAnnotation("haha")
	public static void main(String[] args) {
		//isAnnotationPresent()Annotation是否在现场，形象化字面化翻译
		if(AnnotationTest.class.isAnnotationPresent(HeiMaAnnotation.class)){
			//getAnnotation得到Annotation
			HeiMaAnnotation ann = (HeiMaAnnotation)AnnotationTest.class.getAnnotation(HeiMaAnnotation.class);
			System.out.println(ann);
			System.out.println(ann.color());//red
			System.out.println(ann.value());//testing
			System.out.println(ann.arr().length);//1
			System.out.println(Arrays.asList(ann.arrs()));
			System.out.println(ann.annotatioArr().value());//laobi
			System.out.println(ann.lamp().nextLamp());//RED
			System.out.println(ann.claz().getName());//java.lang.String
		}
	}
}

public @interface MyAnnotation {
	String value() ;
}

 

------- android培训、 java培训、期待与您交流！ ----------　　详细请查看： http://edu.csdn.net/heima/