Java基础加强_Eclipse、枚举、反射、注解、泛型、类加载器、动态代理

第1单元：Eclipse开发工具

eclipse及IDE开发工具介绍

MyEclipse是eclipse的一个插件，使得eclipse可以开发JavaEE项目

javaw.exe是启动java的图形界面所用的虚拟机

Java EE: Java Enterprise Edition

IDE: Integrated Development Environment

WorkSpace:工作间

工程管理与快捷键设置

一个工作间workspace的设置应用于它包含的所有project

设置整个工作间编译器版本和运行时环境的版本

window-->Preferences-->Java-->compiler或者installed JREs

切换workspace：File-->Switch Workspace，自命名一个workspace，没有则自动创建并打开一个工作间

perspective：透视图

每个java文件都要有一个包名，包名是公司的网址倒着写（去哪个公司面试包名就写哪个公司）

想要更改工程名，右键工程名选重构refactor-->rename。如果别的地方调用了这个类，类名也会跟着改，这就是重构的好处

为当前工作间下所有的工程设置快捷键

window-->preferences-->general-->Keys，输入content assist，选择unbind command解除原绑定，然后再设置新的快捷键，注意不要和其他快捷键冲突

查看工程所在目录：安装OperExplorer插件，点击Open Explorer图标即可

eclipse快捷键

提示快捷键：比如设置content assist：alt + / ，输入syso再按该快捷键就可以输出打印语句。注意：一般自动补全快捷键：word completion的快捷键默认也是alt+/，所以此时需要对其进行修改

Ctrl+z/y：取消/还原上次操作

Alt+↓： 移动当前行

Ctrl+Alt+↓： 复制当前行到下一行(复制增加) 

Ctrl+Alt+↑ ：复制当前行到上一行(复制增加)

Ctrl+I ：正确缩进代码

Ctrl+/ ：单行注释

Ctrl+Shift+/ ：多行注释

Ctrl+T：查看类或者接口的实现类

Alt+Shift+r ：选中所有同一变量，方便进行批量修改

Alt+Shift+S/右键选Source-->Generate Constructor using Fields：Eclipse自动根据定义好的字段生成构造函数

直接复制源代码在某包下，自动生成相应文件！

视图管理与程序调试

一个透视图perspective就是若干个小窗口view的集合

如果关闭了一个view就点window-->show view来打开

调试一个变量debug步骤

1. 在需要debug的代码前双击产生端点
2. 点右键单击debug as进如debug透视图
3. 鼠标选中一个变量，右键选watch就可以看到它的值
4. 选择step over先前走一步观察变量的变化

配置eclipse的编译与运行环境

如何设置单个工程的Javac和Java？

选择工程右键选properties-->compiler设置javac

右键选择run as 中的configurations来设置java运行环境

高版本的JRE能否运行低版本的javac编译的程序？可以

低版本的JRE能否运行高版本的javac编译的程序？不可以，会出现bad version number in .class file错误

在eclipse中配置java模板代码

选取一段代码，右键选择surround with 选取需要生成的模板代码

自己配置需要的模板：

preferences-->java-->Editor下拉-->templates中new一个自定义模板，需要在模板中定义cursor和line_selection

在eclipse中导入已有的工程

首先，将工程文件拷贝至workspace目录下

然后，File-->Import-->Genereal-->Existing Projects into Workspace/File System选择该工程的根目录确认即可

如果导入工程的JRE和自己eclipse的JRE不一样（比如JRE的安装目录以及JRE所含的jar包不一样），右键工程名-->build path-->configure build path-->libraries下把该工程原JRE库删除，再增加自己的JRE库

add jars：增加单独的jar包（当jar包存在于工程内但未导入）

add external jars：要导入不在工程内的jar包

add library：增加一个库，该库中有许多jar包

可以自定义一个库，选择User Library，命名一个新的库，然后再在库里增加jar包

第2单元：java5的一些简单新特性

java5的静态导入与编译器语法设置

import可以导入某个类或者某个包中的所有类

import static导入一个类中的某个 静态方法或者所有静态方法

import static java.lang.Math.max;//注意不要写掉static
...
System.out.println(max(3,6));//省略调用类名

如果编译器的jdk版本低于1.5会报错！

Java5的可变参数与OverLoad与Override相关面试题

一个方法接受的参数个数不固定时，就使用可变参数

可变参数VariableParameter的特点：

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

public static int add(int x,int... args){
	int sum = x;
      /*for(int i=0;i

面试题：overload vs override

两个方法的参数列表完全一样但是返回值不一样，不是overload，overload只看同名函数的参数列表，参数列表不同的函数才能实现重载

父类方法私有，子类的一个方法与之一模一样，不是override

Java5的增强for循环

语法：for(变量类型   变量名 : 集合变量名) { ... } 

使用见上面代码

学会阅读java的语言规范langspec-3.0

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

自动装箱：Integer num1 = 12;

自动拆箱：num1+12;

Integer num1 = 13;

Integer num2 = 13;

num1和num2为同一个对象

Integer num1 = 137;

Integer num2 = 137;

num1和num2不是同一对象，与字符串一样

手动包装同自动装箱一样！

Integer num3 = Integer.valueOf(213)

原因： 为了节省内存空间，因为小的数使用频率高，大数适用频率低，所以对于-128~127之间的数字，一旦被包装成一个Integer对象之后就会被缓存起来，当下一个又被装成Integer对象时，先看缓存池中有木有，有就直接拿来用。

以上的设计是一种设计模式： 享元模式 flyweight

当一个对象经常使用，大量重复，就将其设计成享元模式，把相同的属性用对象包装，称为内部状态，不同的变成外部属性，作为方法的参数传入，比如字母i，字符char为相同属性，位置为不同的变量，i.display(x,y)

第3单元：Java5的枚举

枚举的作用

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。

枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

用普通类模拟枚举的实现原理

定义一个WeekDay的类来模拟枚举功能：

• 私有的构造方法
• 每个元素分别用一个公有的静态成员变量来表示
• 可以有若干公有方法或者抽象方法，例如要提供nextDay()方法必须是抽象的

public abstract class WeekDay1 {
	private WeekDay1(){}	
	public final static WeekDay1 SUN = new WeekDay1(){
		public WeekDay1 nextDay() {
			return MON;
		}
		
	};
	public final static WeekDay1 MON = new WeekDay1(){
		public WeekDay1 nextDay() {
			return SUN;
		}
		
	};	
	
	public abstract WeekDay1 nextDay(); //采用抽象方法定义nextDay就将大量的if else语句转移成了一个个独立的类，这里在对象实例化时用匿名内部类来定义子类对象，public可以让子类实现该方法
	
/*	public WeekDay nextDay(){
		if(this == SUN){
			return  MON;
		}else{
			return SUN;
		}
	}
*/
	
	public String toString(){
		return this==SUN?"SUN":"MON";
	}
}

枚举的基本应用

枚举是一种特殊的类，不用关键字class标识，而是通过关键字 enum来标识一个枚举类，每一个枚举元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName()和WeekDay.class.getName();

枚举类的方法

非静态方法：name，toString，ordinal

静态方法：values，valueOf

		public static void main(String[] args) {
			WeekDay weekDay2 = WeekDay.FRI;//访问枚举类中的元素
			System.out.println(weekDay2);
			System.out.println(weekDay2.name());//结果为FRI
			System.out.println(weekDay2.ordinal());	//返回weekDay2的排序，此例为5，ordinal意思是序数
			System.out.println(WeekDay.valueOf("SUN").toString());//将SUN字符串包装成一个WeekDay类型的枚举对象，等同于WeekDay.SUN
			System.out.println(WeekDay.values().length); //values返回一个枚举类型数组
		}

可以将枚举定义为内部类，此时：public enum WeekDay{SUN,MON,TUE,WED,THI,FRI,SAT//此后无语句，不需要加分号}}

实现带有构造方法的枚举

元素列表必须放在所有语句之前，包括构造方法，此时元素列表最后要有分号

        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");}
	}

一旦枚举中的元素被访问，所有的元素的构造函数都会被调用

public static void main(String[] args) {
		WeekDay day2 = WeekDay.TUE;
	}

运行结果

实现带有抽象方法的枚举

外部类可以有两个修饰符，一个默认的，一个public

内部类可以有四个访问修饰符

实现一个交通灯的枚举类（最复杂的枚举）

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();//在父类中定义一个nextLamp的抽象方法，通过上面的匿名内部类来定义该方法的实现，public让子类可以实现该方法
	private int time; //每种灯都有一个时间
	private TrafficLamp(int time){this.time = time;}//时间通过构造方法传入，构造方法为private，代表只能在本类中使用
}

说明：new Date(300){};  该写法是允许的，表示子类的构造方法内部会调用父类的构造方法，并且调用的是父类的有参的构造方法，而不需要在子类中写明该调用，参见上面交通灯例子

枚举只有一个元素时，可以作为单例设计模式的一种实现

第4单元：Java1.2的反射

反射的基础_Class类

Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class

要注意与小写的java关键字区别

Class类描述的类的名字，类的访问属性，类所属的包名，字段名称的列表，方法名称的列表等等

Class类不能直接new对象，因为没有构造方法，它的各个实例对象分别对应各个类在内存中的字节码，例如Person类的字节码，ArrayList类的字节码等等

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码

如何得到各个字节码对应的实例对象

1. 类名.class，例如，Class cls1 = Date.class;
2. 对象.getClass()，例如，new Date().getClass();
3. Class.forName(完整的包名+类名)，例如，Class.forName("java.lang.String"); 做反射时主要使用该方法，因为在写源程序的时候还不知道类名，需要作为参数传递。该方法会抛出异常ClassNotFoundException

面试题：forName的作用是返回字节码，返回的方式有两种：1，字节码已经被JVM加载过，直接返回。2，JVM里还没有该字节码，则用类加载器加载，把加载进来的字节码缓存在虚拟机里面，再返回

九个预定义Class实例对象

8个基本数据类型+1个void关键字

参看Class的isPrimitive()方法的帮助

类名.isPrimitive()判断该类是否为原始类型

int.class == Integer.TYPE的结果为true，因为TYPE字段代表被包装的基本数据类型的字节码

数组类型的class实例对象判断使用的是Class 的isArray()

                String str1 = "abc";
		Class cls1 = str1.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1 == cls2);//true，内存中只会有一份字节码文件
		System.out.println(cls1 == cls3);//true
		
		System.out.println(cls1.isPrimitive());//fasle
		System.out.println(int.class.isPrimitive());//true
		System.out.println(int.class == Integer.class);//false
		System.out.println(int.class == Integer.TYPE);//true,TYPE字段代表被包装的基本数据类型的字节码
		System.out.println(int[].class.isPrimitive()); //false
		System.out.println(int[].class.isArray());//true

总之，只要是在源程序中出现的类型，都有各自的class实例对象，例如int[],void

理解反射的概念

反射就是将java类中的各种成分映射成相应的java类

例如，一个java类用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示。

表示java类的Class类显然要提供一系列的方法来获取其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应的类的实例对象来表示，它们是Field，Method，Constructor，Package等等

一个类中每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class实例对象的方法可以得到这些实例对象并加以应用。

构造方法的反射

Constructor类的对象代表某个类中的一个构造方法

得到某个类所有的构造方法

Constructor [ ] constructors = Class.forName("java.lang.String").getConstructors();

得到某一个构造方法

Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);//传入的是Class对象，通过参数列表来确定要得到那个构造方法，注意获得构造方法时要用到的类型

创建实例对象

一般方式：new String(new StringBuffer("abc")); 

反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));//因为编译时编译器不知道该构造方法对象constructor是属于哪个类的，只有运行时程序才知道，所以写程序时要加上类型强转(String)告诉编译器，注意调用创建实例对象的newInstance方法时要用到上面相同类型的实例对象

Class的newInstance()方法

例子：String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的不带参数的构造方法，然后用该构造方法创建实例对象。省略了获取构造方法的步骤

该方法内部的具体代码是怎样写得呢？用到了缓存机制来保存默认构造方法的实例对象，所以反射会导致程序性能下降

成员变量的反射

Field类的对象代表某个类中的一个成员变量

Eclipse自动生成构造函数源代码：定义好字段，Alt+Shift+S/右键选Source-->Generate Constructor using Fields

public class ReflectPoint {
	public int y;
	private int x;
	int z;
	public ReflectPoint(int x, int y,int z) {
		super();
		this.x = x;
		this.y = y;
		this.z = z;
	}
}

通过反射进行操作：

        ReflectPoint pt1 = new ReflectPoint(3,5,2);
	//被public修饰的变量，通过getField方法获取
	Field fieldY = pt1.getClass().getField("y");//fieldY的值是多少？是5,错！fieldY不是对象身上的变量的值，而是类上定义的变量"y"，要用它去取某个对象上对应的值
	//在pt1对象身上拿到对应的变量的值，结果为3
	System.out.println(fieldY.get(pt1));
	//对于只要是在类中声明过的成员变量（包括public），都可以通过getDeclaredField方法获取
	//被private修饰的变量，只能通过getDeclaredField方法获取（让该字段可见，但是还不能获取该字段的值）
	Field fieldX = pt1.getClass().getDeclaredField("x");
	//然后通过setAccessible将该变量的值设置为可以访问，也叫暴力反射(让该字段的值可以拿到)
	fieldX.setAccessible(true);
	//打印结果为5
	System.out.println(fieldX.get(pt1));
	//无访问修饰符的变量，只能通过getDeclaredField方法获取
	Field fieldZ = rp.getClass().getDeclaredField("z");
	//此时该变量的值即可访问，结果为2
	System.out.println(fieldZ.get(rp));

成员变量反射的综合案例

将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的“b”改成“a”

        private static void changeStringValue(Object obj) throws Exception {
		Field[] fields = obj.getClass().getDeclaredFields();
		for(Field field : fields){
			//if(field.getType().equals(String.class)){
			if(field.getType() == String.class){ //字节码，也就是Class类的对象，用等号比较地址值，因为内存中都只有一份
				String oldValue = (String)field.get(obj);
				String newValue = oldValue.replace('b', 'a');
				field.set(obj, newValue);//最后还要给对象中的成员变量赋值
			}
		}
		
	}

成员方法的反射

Method类的对象代表某个类中的一个成员方法

得到类中的某一个方法

Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class); //int.class表示的是参数类型，通过此列表来明确多个重载方法中的一个

调用方法

• 通常方式：str.charAt(1);
• 反射方式：charAt.invoke(str,1); //str为调用该方法的对象，1为传入该方法的参数，invoke方法参考画圆的方法circle.draw()，画圆的参数是圆的私有属性，所以画圆的方法是属于圆的（专家模式）

如果传递给Method对象的invoke方法的第一个参数为null，说明该Method对象对应的是一个静态的方法

jdk1.4和jdk1.5的invoke方法的区别

• jdk1.5: public Object invoke(Object obj, Object...args)
• jdk1.4: public Object invoke(Object obj, Object [ ] args), 即按照jdk1.4的语法，当需要将一个数组作为参数传递给invoke方法时，数组中的每个元素会分别对应被调用方法中的一个参数。jdk1.5兼容jdk1.4，因此调用charAt方法的代码也可以用jdk1.4改写为charAt.invoke(str, new Object[]{1})的形式

对接收数组参数的成员方法进行反射

点击类名，按F2可以显示完整的包名.类名。再右键选择run as-->run configurations-->Arguments可以给main函数传递想要的字符串参数

目标：

• 写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法 String startingClassName = args[0];//用户传入的参数是一个完整的class类名       Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);

问题：

• 启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数。当把一个字符串数组作为参数传递给invoke方法时，javac为了让1.5的语法兼容1.4的语法而按照1.4的语法处理，即把数组打散成为若干个单独的参数。所以再给invoke方法传递参数时，不能使用代码mainMethod.invoke(null, new String[]{"xxx"})，javac只把它当做jdk1.4的语法进行理解，因此会出现参数类型不匹配的问题。

解决办法：

• mainMethod.invoke(null, new Object[] {new String[]{"xxx"}})，这样每一个数组也是一个Object对象，只拆一次包，得到一个字符串数组
• mainMethod.invoke(null, (Object)new String[]{"xxx"});，编译器会做特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成为若干个参数了。

数组的反射

数组与Object的关系及其反射类型

• 具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象
• 代表数组的Class实例对象的getSuperclass()方法返回的父类为Object对应的Class
• 基本类型的一维数组可以被当做Object类型使用，不能当做Object [ ]类型使用，因为int为基本数据类型，不是Object类型。非基本类型的一维数组，既可以当做Object类型，也可以当做Object [ ]类型
• Arrays.asList(T...a)方法处理int[]和String[]时的差异，处理int[]时，会把整个数组当做list集合的一个元素，因为基本类型的一维数组被当成Object类型使用，处理String[]时，会把数组中的每个元素转化成list集合的每一个元素

int [ ] a1 = new int[3];

Object obj1= a1;//编译通过

Object [ ] obj2 = a1; //会编译出错

asList与toArray

asList(T...a)方法，Arrays工具类的方法，参数a表示支持列表的数组（int[]就不支持）。该方法同toArray()一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回一个受指定数组支持的固定大小的列表

toArray()方法，被Collection对象调用，返回包含此 collection 中所有元素的数组。此方法充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。

数组反射的应用

java.lang.reflect.Array类用于完成对数组的反射操作

以下方法打印一个传入的对象，如果该对象是数组，则打印出元素

        private static void printInfor(Object obj) {
		Class clazz = obj.getClass();
		if(clazz.isArray()){
			int length = Array.getLength(obj);//这里的Array是java.lang.reflect.Array
			for(int i=0;i

怎么得到数组中的元素类型？通过数组名.getClass()得到

ArrayList_HashSet的比较及Hashcode分析

只有存储集合是哈希算法的，hashCode方法才有价值

不覆写hashCode，则根据对象内存的地址值计算哈希值，即使两个对象内容相同，但是因为哈希值不同所以都会存进HashSet

覆写hashCode方法就会根据对象的字段值计算哈希值，两个相同内容的对象就会有一样的hash值，在HashSet中这两个对象只能存一个

当一个对象存储进HashSet集合中以后，就不能修改那个对象中参与计算哈希值的字段了，因为在删除该对象时会因此在HashSet中找不到该对象，防止 内存泄露（对象不需要了，但是却一直占用内存空间）

注意：在类中对其父类Object类的equals方法进行覆盖时，注意传入参数类型一定是equals( Object obj)，而不是该类的类型，否则就成函数的重载了

框架的概念及用反射技术开发框架的原理

反射的作用-->实现框架功能

框架与工具类区别

• 我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。
• 框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题

• 因为在写框架的程序时无法知道要被调用的类名（因为类由以后的用户定义），所以，在程序中无法直接new某个类的实例对象了，而要用反射的方式来做

综合案例

首先直接用new语句创建ArrayList和HashSet实例对象

然后采用配置文件加反射的方式创建ArrayList和HashSet的实例对象

创建配置文件：创建一个File，命名为config.properties，写入className = java.util.ArrayList，注意都不要加引号

	public static void main(String[] args) throws Exception{
		//首先加载该配置文件
		InputStream ips = new FileInputStream("config.properties");//这里使用多态，尽量面向父类或接口编程，但是实际项目中不会使用相对路径设置配置文件		
		//创建Properties对象，它等效于HashMap（有键值对），可以在初始化时从文件里把键值对加载进来，也可以把内存里的键值对存到硬盘去
		Properties props = new Properties();
		props.load(ips);//加载流资源
		ips.close();//流资源一加载完就关闭流，否则会造成因为系统资源没有释放的内存泄露，这里该对象还存在，会由JVM的垃圾回收器管理
		String className = props.getProperty("className");
		Collection collections = (Collection)Class.forName(className).newInstance();//调用不带参数的构造方法

		//Collection collections = new HashSet();
		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);	

		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);	

		System.out.println(collections.size());
	}

用类加载器的方式管理资源和配置文件

通常不会把源程序.java文件直接给用户，而是把.class文件打包成jar包给用户，而且在eclipse下源程序目录下的java文件一保存会自动在classpath目录下生成一份.class文件，并且对于源程序目录下的非java文件，比如配置文件，会直接拷贝一份到classpath目录下

配置文件的路径设置

在命令行下的文件的相对路径一定是相对当前工作目录的路径的，比如c:\Documents and Settings\IBM>java MyClass xx.file，xx.file既不是相对于java.exe文件，也不是相对于MyClass.class文件，而是在IBM目录下，也就是在当前工作目录下（c:\Documents and Settings\IBM）去运算的。

只要classpath指向了MyClass.class文件，在任意目录下都可以运行MyClass.class文件。所以在实习项目中，配置文件的路径不使用相对路径，因为不确定相对路径的目录，要用绝对路径。

绝对路径的盘符不是硬编码写入的（因为可能该盘符不存在），而是通过某种方式get而来。

得到资源文件路径的三种方式

1. JavaWeb的API提供了一个方法getRealPath()，可以得到整个Web项目在硬盘上的具体目录。比如对于“金山词霸”这个项目，配置文件存放在该项目的内部，首先通过getRealPath方法不管用户安装在哪个目录下，可以得到总目录（整个金山词霸项目）在硬盘上的绝对位置，然后拼接上配置文件的内部地址，即金山词霸某个文件的目录，就可以得到该配置文件真实的完整位置（金山词霸/内部地址）。不管是读取还是写入配置文件都可以，注意一定要记住使用完整的路径，该文件一定要存放在程序内部。但完整的路径不是硬编码，而是运算出来的。
2. 最常用（但不能替代上面的方式）：通过类加载器加载配置文件。原理：它可以将运行的类的.class文件加载到内存里面，因此也可以将classpath下的资源文件加载进来，比如：InputStream ips= ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");//会在classpath指定的目录下（即cn/itcast/day1/）逐一地查找要加载的文件（注意最前面不要加斜杠），如果只写config.properties就会默认在classpath指定的根目录下查找。但是这种方法对于配置文件只能读，不能写，因为没有OutputStream。对于类加载器的方式，配置文件都应该放在classpath目录下。Eclipse操作技巧：要将文件进行移动，可以直接进行拖拽操作。
3. 简化的方法：类直接加载（内部都是调用的ClassLoader）：InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");// 只有文件名。配置文件与class文件在同一个包中。最前面没有斜杠，表示相对路径。                                                                                                                 InputStream ips = ReflectTest2.class.getResourceAsStream("resources/config.properties");//存放配置文件的resource包是class文件所在包的子包。最前面没有斜杠，表示是相对路径。
        InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resources/config.properties");//最前面加了斜杠，表示与class文件的当前目录无关，应从classpath根目录开始写上完整的路径cn/itcast/day1/resources/

总结：如果资源文件与class文件的包有关系，就用相对路径，如果与该包没关系，就用绝对路径。

由内省引出JavaBean的讲解

内省：IntroSpector，字面意为对内部进行检查，主要为了对JavaBean进行操作

JavaBean是一种特殊的Java类，主要用于传递数据信息，这种Java类的方法主要用于访问私有字段，且方法名符合某种命名规则，比如 int getAge()和void setAge(int age)以小写的get和set开头

如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。JavaBean的属性是根据其中的setter和getter方法来确认的，而不是根据其中的成员变量

JavaBean可以当做普通类操作，普通类不一定能当JavaBean操作，除非有set和get方法

去掉set和get以后，剩下的名称就是该JavaBean的属性名，比如getAge-->age  getCPU-->CPU。原则： 如果第二个字母是小写，就把第一个字母小写

总之，一个类被当做JavaBean使用时，JavaBean的属性是根据方法名推断出来的，根本看不到java类内部的成员变量。

对JavaBean的简单内省操作PropertyDescriptor

在JavaEE开发中，经常要使用JavaBean

JDK提供了对JavaBean进行操作的一系列API，这套API就称为内省。用内省这套API操作JavaBean比用普通类的方式更方便。

Eclipse技巧：

1. 自动生成setter和getter方法：右键-->source-->Generate setters and getters
2. 将选中的代码重构抽取为一个方法：右键-->refractor-->extract method

演示将一个类当做JavaBean并利用内省API：PropertyDescriptor 来读取JavaBean的属性，然后再设置JavaBean的属性

	public static void main(String[] args)throws Exception {
		ReflectPoint rp = new ReflectPoint(1,3);		
		//用户提供的属性值，如果按照一般类利用反射方式，应将用户提供的属性值进行如下转换："x"-->"X"-->"getX"得到方法名，再对类中的方法进行获取
		String propertyName = "x"; 
		//当做JavaBean处理利用内省API中的PropertyDescriptor
		//两个参数，一个是需要获得的JavaBean的属性名称，二是该JavaBean的类,最好采用obj.getClass方式，更通用
		PropertyDescriptor pd = new PropertyDescriptor(propertyName,rp.getClass());
		//获取读取方法
		Method methodGetX = pd.getReadMethod();
		//利用反射调用该方法返回属性值，注意retVal的写法(return value的简写)
		Object retVal = methodGetX.invoke(rp);
		System.out.println(retVal);	
		//获取写入方法
		Method methodSetX = pd.getWriteMethod();
		//利用反射调用该方法写入新值
		methodSetX.invoke(rp, 99);
		System.out.println(rp.getX());
	}

对JavaBean的复杂内省操作BeanInfo

采用BeanInfo获取所有属性方式来查找和设置某个ReflectPoint对象的x属性。

在程序中把一个类当做JavaBean来看，就是调用IntroSpector.getBeanInfo方法，得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息

        //利用refactor将上面的部分代码提取成一个getProperty方法
	private static Object getProperty(Object pt1, String propertyName)
	throws IntrospectionException, IllegalAccessException,
	InvocationTargetException {
		//利用PropertyDescriptor获取，简单
		/*PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
		Method methodGetX = pd.getReadMethod();
		Object retVal = methodGetX.invoke(pt1);*/
		//利用BeanInfo获取，需要迭代，复杂
		BeanInfo beanInfo =  Introspector.getBeanInfo(pt1.getClass());
		PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
		Object retVal = null;
		for(PropertyDescriptor pd : pds){
			if(pd.getName().equals(propertyName))
			{
				Method methodGetX = pd.getReadMethod();
				retVal = methodGetX.invoke(pt1);
				break;
			}
		}
		return retVal;
	}

使用BeanUtils工具包操作JavaBean

BeanUtils是开源Apache提供的工具类，下载后解压会有三个jar包，其中common-beanutils包包含了其他两个子jar包，拷贝它就行了

先用Eclipse导入BeanUtils的jar包，等程序运行出错后再引入logging包

导入jar包的两种方式

第一种直接从外部导入至工程，右键点工程名，选择build path-->Configure Build Path-->Libraries-->Add External JARs。但是将工程拷贝给他人时会找不到jar包

第二种在本工程目录下新建一个普通的lib文件夹（用于放所有的库），在Eclipse中把需要导入的jar包复制粘贴到该目录下，虽然此时该jar包在工程内部，但是还没有加入到build path中，然后右键该jar包，build path-->add to build path，当该jar包前面变为小奶瓶时就完成了导入，这样项目拷贝给他人时该jar包也一同拷过去了

此例中的BeanUtils包用到了其他的jar包，日志开发包logging，所以也需要导入该包

getProperty与setProperty方法

在上面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值，get属性时，接受一个字符串，返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串

注意要操作的JavaBean必须是public修饰的

BeanUtils.getProperty(rp, "x")//获得javabean rp 的x的值

BeanUtils.setProperty(rp, "x", "90");

BeanUtils.setBirthday(rp, " birthday.time", "111"); //属性的级联操作，此时ReflectPoint内有一个Date类型的birthday属性，time为Date的一个属性（把Date当javabean看），可以通过BeanUtils来操作它

BeanUtils.getBirthday(rp, " birthday.time");

BeanUtils工具包的好处

自动完成类型转换（字符串直接转换成相应类型），支持属性的级联操作

BeanUtils工具包的其他方法

将一个JavaBean的属性复制到另一个JavaBean：copyProperties(Object dest, Object orig)

将JavaBean转成Map：describe(Obejct bean)

将Map转成JavaBean：populate(Object bean, Map properties)

用BeanUtils直接操作Map对象

Java 7 的新特性

Map map = {name:"adf", age:23};

BeanUtils.setProperty(map, "name", "ljljl");//用BeanUtils直接操作Map对象

PropertyUtils工具包

用PropertyUtils类先get原来设置好的属性，再将其set为一个新值，get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。

想自动类型转换就用BeanUtils，如果转换出错或者不需要转换就用PropertyUtils

第5单元：Java5的注解

注解：Annotation

了解和入门注解的应用

注解用于向java编译器传递信息

注解相当于一种标记，在程序中加了注解就相当于为程序打上了某种标记。javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，根据相应标记去做相应的事。

标记可以加在包、类、字段、方法、方法的参数以及局部变量上。

一种注解就是一个类，使用一个注解就相当于创建了一个注解的实例对象

压缩警告注解

System.runFinalizersOnExit(true); 

该方法已过时，在Eclipse中会有删除线

在命令行中的执行：

如果API升级了，被调用的某个方法被编译器提示过时(deprecation)，就可以在调用该方法的方法前面加一个 "压缩警告"注解@SuppressWarnings("Deprecation")告诉编译器忽略“过时”。

Deprecation：过时

压缩警告是jdk自己内部的一个注解

过时注解

用过时注解标记过时方法，提示新的开发人员不再调用该方法，而不是直接删除过时的方法，这样就允许其他调用过方法的程序还能正常运行

使用：在方法前加上@Deprecated

覆盖注解

在类中覆盖父类的方法时，在该方法前加上@Override注解，如果写成了重载，编译器会提示报错

注解的定义与反射调用

注解的定义

注解就相当于你的源程序中要调用的一个类，要在源程序中应用某个注解，得先准备好这个注解类，就像你要调用某个类，得先开发好这个类

创建一个注解

格式：public @interface XXXAnnotation { }

Eclipse右键直接new一个Annotation

元注解

注解上的注解，例如：

@Retention(RetentionPolicy.RUNTIME)

public @interface A { }

@Retention

retention：保留

该元注解有三种取值：RetentionPolicy.SOURCE、RetentionPolicy.CLASS、RetentionPolicy.RUNTIME分别对应java源文件-->class文件-->内存中的字节码

javac把源文件编译成class文件时可能去掉注解

类加载器将class文件加载进内存中也有可能去掉注解

所以在设计注解时需要加上@Retention来标注该注解的生命周期

默认值是在CLASS阶段

@Override和@SuppressWarnings的生命周期都在SOURCE阶段

@Deprecated的生命周期在RUNTIME阶段，因为会根据调用该方法的类的字节码查看该类是否过时

@Target

用于说明注解可以应用在哪个成分上

属性值：ElementType.METHOD、ElementType.TYPE（TYPE的意思包括了class，interface，enum）、FIELD、LOCAL VARIABLE、PAKAGE、PARAMETER、CONSTRUCTOR、ANNOTATION_TYPE

默认值为任何元素，设置Target等于ElementType.METHOD，原来加在类上的注解就报错了，改为用数组方式设置@Target({ElementType.METHOD,ElementType.TYPE})就可以了

注意导入import java.lang.annotation.*;

注解的反射调用

main方法必须放在一个类中，但是不属于该类。

                //首先判断注解是否应用在该类上
		if(B.class.isAnnotationPresent(A.class))
			A a = (A)B.class.getAnnotation(A.class);//得到注解的实例对象，但是编译时不知道是哪一个具体的注解，运行时才知道，所以要强转

此时需要在注解类A上加元注解Retention并设置值为RetentionPolicy.RUNTIME，让该注解A保留在运行时内存的字节码中。否则运行程序时，判断注解会返回false

为注解增加各种属性

什么是注解的属性？

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是某个学校的学生，如果还想区分出是哪个班的学生，这时可以为胸牌增加一个属性进行区分。

加了属性的标记效果为：@MyAnnotation(color = "red")

定义和应用基本类型的属性

在注解类中增加String color();//注解中对属性的定义很像接口中的方法，定义了属性之后，注解后必须对属性进行设置，否则编译错误。

@MyAnnotation(color = "red");

value属性的特殊应用

对于注解中只有一个名为value的属性需要设置，这时可以不写属性名，只写属性值。@MyAnnotation("red");

属性的默认值

可以为属性指定缺省属性，例如 String color() default "blue";

为注解增加高级属性

数组类型的属性

int[] arrayAttr() default {1,2,3};
@MyAnnotation(arrayAttr = {2,3,4})
如果数组属性中只有一个元素，这时候属性值部分可以省略大括号，例arrayAttr = 1，@Target(ElementType.METHOD)--属性的名称为value
int [ ] 因为不是Object [ ]，只当做一个Object，所以不能用asList转为list

枚举类型的属性

EnumTest.TrafficLamp lamp() ;//该枚举为EnumTest中的内部类
@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

注解类型的属性

定义一个注解属性：MetaAnnotation annotationAttr() default @MetaAnnotation("xxxx");

注解中的属性值还是一个注解：@MyAnnotation(annotationAttr=@MetaAnnotation(“yyy”) )
可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调用代码如下：
MetaAnnotation ma =  myAnnotation.annotationAttr();
System.out.println(ma.value));
注解的详细语法可以通过看java语言规范了解，即看java的language specification。

第6单元：java5的泛型

入门泛型的基本应用

Jdk 1.5以前的集合类中存在的问题

        ArrayList collection = new ArrayList();
	collection.add(1);
	collection.add(1L);
	collection.add("abc");
	int i = (Integer) collection.get(1);//编译要强制类型转换且运行时出错！

Jdk 1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据

ArrayList collection2 = new ArrayList();
collection2.add(1);
/*collection2.add(1L);
collection2.add(“abc”);*///这两行代码编译时就报告了语法错误
int i2 = collection2.get(0);//不需要再进行类型转换

不仅使用集合时用到了泛型，使用反射时也用到泛型

                Class clazzString = String.class;
		Constructor con = clazzString.getConstructor(StringBuffer.class);
		String s1 = con.newInstance(new StringBuffer("abc"));//不需要再进行String的类型转换了
		System.out.println(s1.charAt(2));

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

在JDK 1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告（黄色灯泡）。可以用suppress warning注解让其不要报告

泛型的内部原理及更深应用

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译完带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，因此，对于参数化的泛型类型（比如ArrayList），getClass()方法的返回值和原始类型（比如ArrayList）完全一样：

//用下面的代码查看getClass()方法返回的结果已经去掉了“类型”信息。
System.out.println(new ArrayList().getClass().getName());
System.out.println(new ArrayList().getClass().getName());

由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

                ArrayList al1 = new ArrayList();
		ArrayList al2 = new ArrayList();
		System.out.println(al1.getClass()==al2.getClass());//结果为true，证明了泛型的去类型化
		//al2.add("abc");编译会报错，下面用反射跳过编译器添加字符串
		Method m = al2.getClass().getMethod("add",Object.class);
		m.invoke(al2, "abc");
		System.out.println(al2.get(0));

ArrayList类定义和ArrayList类引用中涉及如下术语：

• 整个称为ArrayList泛型类型
• ArrayList中的E称为类型变量或类型参数
• 整个ArrayList称为参数化的类型
• ArrayList中的Integer称为类型参数的实例或实际类型参数
• ArrayList中的<>念着typeof
• ArrayList称为原始类型

参数化类型与原始类型的兼容性：

• 参数化类型可以引用一个原始类型的对象，编译报告警告，例如， Collection c = new Vector();//可以，例如jdk1.4的一个方法返回一个原始类型的集合对象，在jdk1.5中要使用参数化类型接受该方法的返回值，为了兼容jdk1.4，编译器会允许。所以可不可以，不就是编译器一句话的事吗？
• 原始类型可以引用一个参数化类型的对象，编译报告警告，例如， Collection c = new Vector();//例如jdk1.4的某个方法接受一个集合参数，该参数是原始类型的，在jdk1.5中调用该方法需要传递一个参数化类型的对象进去，兼容性考虑编译器会允许新的类型能传进去

参数化类型不考虑类型参数的继承关系：

• Vector v = new Vector