JavaSE 拾遗(15)——JavaSE 高新技术基础增强...java5简单新特性和枚举

JavaSE 高新技术基础增强有下面的内容

第2单元：eclipse开发工具
第3单元：java5的一些简单新特性
第4单元：java5的枚举
第5单元：反射的深入讲解
第6单元：java5的注解
第7单元：java5的泛型
第8单元：类加载器的深入讲解与应用
第9单元：动态代理技术的深入讲解

1.eclipse 开发工具

eclipse 及 IDE开发工具介绍
eclipse工程管理与快捷键配置
eclipse视图管理与程序调试
配置eclispe的编译与运行环境
在eclispe中配置java模板代码
在eclipse中导入已有的工程

java preference 的配置和 workspace 是一一对应的，一旦 workspace 改变，配置将改变，在 workspace 里面还有和各种开发语言一一对应的配置

Java 模板的配置，模板是跟语言相关的，所以在 Preference ——> Java ——> Editor ——> Templetes 里面配置 Java 的模板

2.java5的一些简单新特性

java5的静态导入与编译器语法设置
可变参数与OverLoad相关面试题分析
java5的增加for循环
基本数据的自动拆装箱及享元设计模式

java5 的静态导入

/**
 * 需求：演示静态导入的使用
 * 
 * 思路：
 * 
 * 步骤：
 * 
 * 总结：
 * 静态导入是 xxx，用来做 xxx，为什么有静态导入，静态导入为什么是这样
 * 
 * 1.静态导入是 xxx
 * 概念: 静态的导入类中的静态成员
 * 格式: import static 包名.类名.静态成员名;
 * 源代码
 * 
 * 2.用来做 xxx(总结的角度)
 * 什么情况下用、优点、缺点
 * 静态导入，主要的作用是方便在使用某个类的静态成员的时候，可以不用写类名
 * ， 直接使用成员名调用，好处是简化书写，设计类时可以把某些常量用接口封装
 * 在一起, 使代码看起来更整洁，弊端是引入了不必要的混淆,降低了代码的阅读性
 * 所以 java 中静态导入的使用原则是：限制静态导入的使用，不要在应用程序中普
 * 遍使用静态导入。因为 java 作为一个计算机语言，最重要的作用就是要便于表达
 * 人的设计思想，以及便于人的阅读。
 * 
 * 源代码
 * 3.为什么有 xxx，为什么是这样
 * 
 * 静态导入————小乘佛法，是解决复杂度的问题，不是解决设计逻辑的可行性问题
 * 但是有的问题复杂度如果太高，也相当于不可以行。
 */
package cn.itcast.day1;

import static java.lang.Math.abs;
import static java.lang.Math.*;
//导入一个类中的一个静态方法
//导入一个类中的所有静态成员

/**
 * @author vivianZhao
 * 
 */
public class StaticImport {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(abs(-5));
		System.out.println(max(3, 6));

	}

}

可变参数和Overload

/**
 * 需求：演示可变参数函数的使用
 *
 * 思路：
 *
 * 步骤：
 *
 * 总结：
 * 可变参数函数是 xxx，用来做 xxx，为什么有可变参数函数，可变参数函数为什么是这样
 *
 * 1.可变参数函数是 xxx
 * 概念：可变参数函数就是函数定义时参数个数不定的，延迟确定参数个数到函数调用时的函数
 * 格式：类型 ... 参数名，比如 int ... args, ... 位于类型和参数名之间，有无空格都可以
 * 在以前参数定义的形式上加上...,
 * 使用注意：可变参数只能出现在参数列表的最后
 * 源代码：
 *
 * 2.用来做 xxx(总结的角度)
 * 什么情况下用：在想要明确表示方法参数是相同类型的参数的个数可变(不定)的设计时用可变参数函数
 * 源代码：
 *
 * 3.为什么有可变参数函数，为什么是这样
 * 为了表达一个方法的参数列表中相同类型的参数的个数，在程序编写时不固定(不确定)的设计，可以用数
 * 组参数来完成， 数组参数的定义形式 add(int [] parameterArr)，在调用这个函数的时候，必须先创建
 * 一个数组作为实际参数。可变参数函数是数组参数函数的简写形式，调用可变参数的方法时，编译器会为
 * 该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数，所以可变参数简化了这种参数不
 * 定的需求下的方法调用的书写。又数组参数不只可以表示参数可变的含义，所以可变参数的表达形式，使
 * 参数可变的含义更明确。
 * 在方法参数列表中的参数定义的时候，没有出现过 ... 这种形式，而自然语言中...通常也用来表示等等
 * 的意思，所以可以在参数类型和参数名之间加...来表示可变参数是完全可以解析和理解的形式
 * 
 * 决定权反转、决定时间反转
 * 决定权反转，主要强调的是拥有决定权的对象和被决定的对象反转
 * 决定时间反转，主要强调下决定的时刻改变，并且时刻具有先后性
 */
package cn.itcast.day1;

/**
 * @author vivianZhao
 *
 */
public class VariableParameter {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1,2,3));
		System.out.println(add(1,2));
	}
	
	public static int add(int x, int ... args){
		int sum = x;
		for(int temp : args){
			sum += temp;
		}
		return sum;
	}
}

java5增强for循环

/**
 * 需求：演示增强型 for 循环
 * 
 * 思路：
 * 
 * 步骤：
 * 
 * 总结：
 * 增强型 for 循环是 xxx，用来做 xxx，为什么有增强型 for 循环， 增强型 for 循环为什么是这样 
 * 1.增强型 for 循环是 xxx
 * 概念：用来对集合对象中的元素内容进行遍历的 for 循环，相当于 c# 中的 foreach(...in...)
 * 格式：for(集合中元素类型 变量名 : 集合对象){...}
 * 源代码：
 * 使用注意：集合对象必须属于实现了 Iterable 接口的类
 * 
 * 2.用来做 xxx
 * 增强型 for 循环用来遍历集合类对象中元素的内容
 * 优点：书写简单，表示遍历集合中元素内容的含义明确
 * 缺点：和普通 for 循环相比不能使用 Iterator 的方法
 * 
 * 3.为什么有增强型 for 循环，增强型 for 循环为什么是这样
 * 因为遍历集合中元素的内容在程序中经常使用，所以单独用一种结构来表达这种设计，是程序更加简单明了。
 * 因为人们已经接受了 for each(... in ...) 的使用方法，for(... : ...) 相当于把 in 替换为了 ： 符号。
 */
package cn.itcast.day1;

/**
 * @author vivianZhao
 *
 */
public class EnhanceFor {

	/**
	 * @param args
	 */
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1,2,3));
	}
	
	public static int add(int x, int ... args){
		int sum = x;
		for(int temp : args){
			sum += temp;
		}
		return sum;
	}

}

基本数据的自动拆装箱及享元设计模式

/**
 * 需求：演示自动装箱拆箱和享元模式
 * 
 * 思路：
 * 
 * 步骤：
 * 
 * 总结：
 * 1.能做什么
 * 自动装箱拆箱，简化了程序的书写
 * 2.是什么
 * 自动装箱和拆箱，是指在 java 源程序中，编译器 javac 把基本数据类型自动按运算符的需要装换为相应基本数据类
 * 型的引用类型，比如把 int 类型数据 12，转换为 (Integer)12；自动拆箱和装箱刚刚相反，是指编译器为了运算符的
 * 需要自动把引用类型的对象转换为其对应的基本数据类型。
 * 3.为什么是这样
 * 
 * 表达式中数据类型的自动转换，是由运算符的需求来决定的，运算符需要什么类型，表达式结果的值就自动转换为什么
 * 类型
 * 
 * 享元模式 、flyweight 模式, flyweight 轻量级，顾名思义，轻量级就是让内存的负担减轻，共享某些必要的对象，
 * 就可以实现这个目的。所以也叫做享元模式。在基本数据类型的装箱里面就有使用了享元模式，对一个字节表示的整形
 * 常量，装箱后都是同一个对象。
 * 
 * 对于某些小的对象，他们有大部分属性相同，一部分属性不同，并且在程序运行过程中这些相同的属性不会被改动，
 * 于是我们就把这些对象相同属性封装成一个对象，称为对象的内部状态，把不同属性封装成方法的参数，称为外部状态
 * ，这样就可以只为这些对象创建一个对象， 这就叫做享元模式。
 * 
 * 从 javap 反编译可以知道，自动装箱拆箱编译器会处理就是调用 Integer.valueOf() 和 Integer.IntValue() 函数，
 * 对应 byte 范围类的数据有享元模式功能，我想也是在这两个函数中实现的
 * 
 */
package cn.itcast.day1;

/**
 * @author vivianZhao
 *
 */
public class BoxingAndUnboxing {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer iObj = 13;					// 自动装箱
		System.out.println(iObj + 12);		// 自动拆箱
		
		int iVariable1 = 15;
		int iVariable2 = 15;
		Integer iObj1 = iVariable1;			
		Integer iObj2 = iVariable2;
		System.out.println(iObj1 == iObj2);	// 享元模式
		
		iVariable1 = 135;
		iVariable2 = 135;
		iObj1 = iVariable1;
		iObj2 = iVariable2;
		System.out.println(iObj1 == iObj2);	// 享元模式在整数里面只对 byte 范围数据有效
		
		String s1 = "abc";
		String s2 = "abc";
		System.out.println(s1 == s2);		// 这里也是享元模式
		
		String s3 = new String("abc");		// 这里使用 new 了就会产生3个对象，1个在常量池，2个在堆中
		String s4 = new String("abc");
		System.out.println(s3 == s4);
	}

}

3.枚举 Enumeration

枚举的作用介绍
用普通类实现枚举
java5的枚举的基本应用
实现带有构造方法的枚举
实现带有抽象方法的枚举

枚举的作用介绍

为什么要有枚举?

枚举的用处：
要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。如果把这种问题定义为 Exception 来提示使用代码的人未免太麻烦，因为每一种这种类型的数据都要定义一个 Exception，为了方便程序员，Java 1.5 又重新支持 Enumeration，

枚举是什么：

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

枚举是一种特殊的类，是一种在类定义的时候我们就已经明确了该类的所有对象的信息和限制的类。在类定义的时候就知道所有对象的名字和个数，所以在l类定义的是就创建好了对象。并且以后不让再创建该类的对象。这种类我们完全可以用普通 class 来定义，但是为了简洁、清晰、明了，我们专门设计了一种关键字 enum 来定义这种类，因为很多信息已经固定，所以定义的语法上删掉了很多不必要的信息，枚举是这种类的一种特定的语法表达形式。

用普通类实现枚举

用普通类如何实现枚举功能，定义一个 Weekday 的类来模拟枚举功能。

/**
需求:自定义一个 WeekDay 类，来模拟枚举类的功能

思路:
1.枚举类定义的变量，只能取枚举中的值，我们可以用普通类的对象来代替枚举类中的值
2.如果不让别人生成新的对象，我们可以把 WeekDay 类的构造函数私有化
3.在 WeekDay 中我们需要提供不同的值，让其变量使用，所以需要定义 public static final 的变量来保存 WeekDay 
对象

步骤:
*/
package cn.itcast.day1;

/**
 * @class: WeekDay
 * @package: cn.itcast.day1
 * @description: TODO
 * @author： vivianZhao
 * @date: 2013-7-19 下午6:37:51
 * @version: 1.0
 */
public class WeekDay {
	private WeekDay(){
		
	}
	
	public static final WeekDay SUN = new WeekDay();
	public static final WeekDay MON = new WeekDay();
}

这样 WeekDay 也相当于一个 Enumeration 的类型了，可以使用 WeekDay.SUN 表示星期天，而且 WeekDay 类型的变量不能取其他值，只能取 WeekDay 的成员。

实例：加上 next 和 toString 功能的 WeekDay

/**
需求:自定义一个 WeekDay 类，来模拟枚举类的功能

思路:
1.枚举类定义的变量，只能取枚举中的值，我们可以用普通类的对象来代替枚举类中的值
2.如果不让别人生成新的对象，我们可以把 WeekDay 类的构造函数私有化
3.在 WeekDay 中我们需要提供不同的值，让其变量使用，所以需要定义 public static final 的变量来保存 WeekDay 
对象
4.如果提供 next 方法，一种实现是在 next 方法中使用 if-else 判断当前对象和那个成员 == ，另一种比较简洁的实现
是使用内部类的方式，在每个成员对象内部重新 next 方法

步骤:

总结：
这里演示了内部类巧妙的使用，把父类里面大量的 if-else 语句转换为一个个独立的类
 */
package cn.itcast.day1;

/**
 * @class: WeekDay
 * @package: cn.itcast.day1
 * @description: TODO
 * @author： vivianZhao
 * @date: 2013-7-19 下午6:37:51
 * @version: 1.0
 */

public abstract class WeekDay {
	private WeekDay() {
	}

	public final static WeekDay MON = new WeekDay() {
		@Override
		public WeekDay next() {
			// TODO Auto-generated method stub
			return TUE;
		}

		public String toString() {
			return "MON";
		}
	};

	public final static WeekDay TUE = new WeekDay() {
		@Override
		public WeekDay next() {
			// TODO Auto-generated method stub
			return MON;
		}

		public String toString() {
			return "TUE";
		}
	};

/*	public WeekDay nexDay() {
		if (this == Mon) {
			return Tue;
		} else {
			return Mon;
		}

	}*/

	public abstract WeekDay next();

	public String toString() {
		return this == MON ? "MON" : "TUE";
	}
}

java5 的枚举的基本应用

/**
 * 需求：演示 enum 的使用
 * 
 * 思路：定义一个 WeekDay 的枚举类型，在 main 函数中演示枚举类和枚举对象相关的功能函数
 * 
 * 步骤：
 * 
 * 总结：
 * java 中枚举和 c 中的枚举功能一样，但是实现原理不同， enum 定义的枚举类，也是类，也有 Class 文件，只是是
 * 一种特殊的类，就像前面我们自己实现的枚举类类似，enum 关键字只是让我们定义枚举这种特殊的类更方便了，简化
 * 了书写，统一了功能函数
 * 1.枚举类的功能函数
 * valueOf 根据字符串获取枚举类型值对象
 * values 获取枚举类型所有值对象构成的数组
 * 还有就是 Class 对象的功能
 * 
 * 2.枚举类值对象的功能函数
 * name 获取值对象的名字
 * ordinal 获取值对象在枚举类中的排名
 * 还有就是 Object 对象的功能
 */
package cn.itcast.day1;

/**
 * @class: EnumDemo
 * @package: cn.itcast.day1
 * @description: TODO
 * @author： vivianZhao
 * @date: 2013-7-19 下午8:38:39
 * @version: 1.0
 */
public class EnumDemo {

	/**
	 * @method: main
	 * @description: TODO
	 * @param args
	 * @return: void
	 * @author： vivianZhao
	 * @date: 2013-7-19 下午8:38:39
	 * @version: 1.0
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WeekDay weekDay = WeekDay.MON;

		// 枚举类值对象的功能函数
		System.out.println(weekDay);
		System.out.println(weekDay.name()); // 获取值对象的名字
		System.out.println(weekDay.ordinal()); // 获取值对象在枚举类中的排名

		// 枚举类的功能函数
		System.out.println(WeekDay.valueOf("MON")); // 根据字符串获取枚举类型值对象
		System.out.println(WeekDay.values()); // 获取枚举类型所有值对象构成的数组
	}

	public enum WeekDay {
		MON, TUE, WED, THU, FRI, SAT, SUN
	}
}

实现带有构造方法的枚举

/**
 * 需求：演示带构造方法的  enum 类的使用
 * 
 * 思路：定义一个 WeekDay 的带构造方法的枚举类型，在 main 函数中演示带钩子方法的枚举类
 * 
 * 步骤：
 * 
 * 总结：
 * 1.枚举类中除了可以定义枚举的值对象(成员变量)，还可以定义和普通类一样的构造方法、成员方法、成员变量
 * 2.如果枚举类中除了枚举值元素的定义，还要定义其他成员，那么其他成员应该放在枚举值元素定义的后面
 * 3.如果枚举类中元素列表后面有成员定义，元素列表后面一定要加上分号，表示语句结束
 * 4.枚举类中元素的创建时随枚举类的加载而创建，创建枚举类的值对象会调用枚举类的默认构造函数
 * 5.如果枚举类中显示定义了构造函数，那么构造函数必须是 private 修饰的
 * 6.如果枚举类中定义了带参数的构造函数，那么可以通过在定义枚举值变量的时候使用(),来指定相应的值对象要调用
 * 带参数的构造函数，这相当于省略了该成员变量定义的部分结构,比如：
 *  public static final 枚举类型 变量名 = new 枚举类型()
 * 7.枚举类型也是一个 Class ，只是是特殊写法的 Class，所以普通类中的东西，枚举类中都可以有，只是那样的枚举
 * 类用起来比较复杂。
 */
package cn.itcast.day1;

/**
 * @class: EnumDemo
 * @package: cn.itcast.day1
 * @description: TODO
 * @author： vivianZhao
 * @date: 2013-7-19 下午8:38:39
 * @version: 1.0
 */
public class EnumDemo {

	/**
	 * @method: main
	 * @description: TODO
	 * @param args
	 * @return: void
	 * @author： vivianZhao
	 * @date: 2013-7-19 下午8:38:39
	 * @version: 1.0
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		WeekDay weekDay = WeekDay.MON; //使用枚举类才会加载枚举类
	}

	public enum WeekDay {
		SUN, MON(2), TUE, WED(1), THI, FRI, SAT;

		private WeekDay() {
			System.out.print("first ");
		}

		private WeekDay(int day) {
			System.out.print("second ");
		}
	}
}

带参数的构造方法，枚举值变量的声明相当于： ~~public static final 枚举类型~~ 变量名 ~~= new 枚举类型~~(实参表)

上面程序执行结果：

实现带有抽象方法的枚举

/**
 * 需求：演示带抽象方法的  enum 类的使用
 * 1.需要一个交通灯类，交通灯对象的值只能是交通灯的颜色 RED、YELLOW、GREEN
 * 2.每个颜色的交通灯都有一个保持时间
 * 3.每个交通灯都还有获取它自身下一个颜色的交通灯的功能
 * 
 * 思路：定义一个 TrafficLamp 的带抽象方法的枚举类型，在 main 函数中演示带构造方法的枚举类
 * 1.交通灯有三个颜色，那么可以使用枚举类来限制交通灯对象的取值
 * 2.每个灯都有一个保持时间的属性，那么可以使用 int 类型成员变量来保存该属性
 * 3.每个灯都有获取写一个颜色灯的能力，那么可以定义一个 nextLamp 函数来返回下一个灯，由于在 TrafficLamp 类
 * 中实现该功能需要比较多的 if-else 判断，所以可以转换为内部类来实现，这就需要用到 enum 类中含有抽象函数的
 * 形式。就是在每个值变量定义的后面用 { } 实现父类的抽象函数。
 * 
 * 步骤：
 * 
 * 总结：
 * 带抽象方法的  enum 类是什么，为什么
 * 带有抽象方法的 enum 类是指在 enum 类定义的时候，类中带有抽象的成员方法
 * 
 * 带抽象方法的  enum 类有什么用
 * 带抽象方法的  enum 类，可以让每个值变量在定义的时候使用内部类实现抽象方法，让每个值对象拥有多态的成员方法
 * 
 */
package cn.itcast.day1;

/**
 * @class: EnumDemo
 * @package: cn.itcast.day1
 * @description: TODO
 * @author： vivianZhao
 * @date: 2013-7-19 下午8:38:39
 * @version: 1.0
 */
public class EnumDemo {

	/**
	 * @method: main
	 * @description: TODO
	 * @param args
	 * @return: void
	 * @author： vivianZhao
	 * @date: 2013-7-19 下午8:38:39
	 * @version: 1.0
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

	// 交通灯枚举(带有抽象方法)
	public enum TrafficLamp {
		REDLAMP(30) {
			public TrafficLamp nextLamp() {
				return GRRMLAMP;
			}
		},
		GRRMLAMP(30) {
			public TrafficLamp nextLamp() {
				return YELLOWLAMP;
			}
		},
		YELLOWLAMP(5) {
			public TrafficLamp nextLamp() {
				return REDLAMP;
			}
		};

		private TrafficLamp(int timp) {
			this.timp = timp;
		}

		private int timp; // 保存交通灯保持的时间
		
		/**
		 * 
		 * @description: 获取下一个颜色交通灯
		 * @param timp
		 * @author： vivianZhao
		 * @date: 2013-7-19 下午10:23:15
		 * @version: 1.0
		 */
		public abstract TrafficLamp nextLamp();

	}
}

带内部类的枚举值变量声明相当于：

~~public static final TrafficLamp~~ REDLAMP ~~= new TrafficLamp~~(40){
public TrafficLamp nextLamp() {
return GRRMLAMP;
}
} ;