黑马程序员---Java高新技术上的总结

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

枚举 反射 泛型 内省 代理

这些感觉讲的都是概念性的东西
现在都用不到
但是很重要，以后会天天接触
大概记录一下
几个重要的地方


枚举:

枚举和类很像

感觉就是有特定规则的类

这一个枚举感觉很典型了

public enum Lamp{
	RED(35){					//枚举可用构造方法，也可实现abstract方法;
		public Lamp nextLamp(){
			return GREEN;
		}
	},GREEN(30){
		public Lamp nextLamp(){
			return YELLOW;
		}
	},YELLOW(5){
		public Lamp nextLamp(){
			return RED;
		}
	};
	private int time;			//枚举也可定义成员变量
	private Lamp(int time){
		this.time=time;
	}
	public abstract Lamp nextLamp();
}

反射:

反射很难理解啊...


获取字节码3种方法:
Date d=new Date();
1.Date.class
2.d.getClass()
3.Class.forName("java.util.Date") //要写包括包名的全称
//内部类的名字:主类名$内部类的类名

方法的反射中获取方法
要传递方法名和方法的参数类型字节码
以区分方法的重载
构造方法不需传递方法名

同数据类型的同维数数组的字节码是同一份
数组的反射感觉要区分好Object的和基本类型的


泛型:

声明泛型的位置:
变量：变量名后
方法：返回值前
类：类名后

泛型的运用现在感觉主要还是在泛型变量
集合之类的,已经开始经常接触了


内省:

主要是JavaBean的内省
操作JavaBean常用的3个类
PropertyDescripter
BeanUtils
PropertyUtils
大概就是反射对于JavaBean的运用
主要是一些API方法


代理:

代理感觉听起来很重要
而且理解起来也有点困难 
反复写了几遍getProxy方法也只找到了点感觉

getProxy方法2个参数
目标和Advice
Advice里面写方法前后，catch语句中的代码
InvocationHandler可以封装在getProxy方法里面
然后就是Proxy的newInstance方法传递的一堆参数
其中实现的接口那里是个数组


最后有个小型Spring框架综合应用
把JavaBean 代理什么的全应用起来了
主要还是要思路清晰
看着张老师写代码 感觉都对
但是自己一写 根本就没有头绪了

下面的代码反复写了几次
算是勉强能自己写出来了

import java.io.InputStream;
import java.lang.reflect.*;
import java.util.Properties;

class BeanFactory{
	Properties prop=new Properties();
	public BeanFactory(InputStream is)throws Exception{
		prop.load(is);
	}
	public Object getBean(String name)throws Exception{
		Object bean=Class.forName(prop.getProperty(name)).newInstance();
		if(bean instanceof ProxyFactoryBean){
			ProxyFactoryBean pfb=(ProxyFactoryBean)bean;
			pfb.setAdvice((Advice)Class.forName(prop.getProperty(name+".advice")).newInstance());
			pfb.setTarget(Class.forName(prop.getProperty(name+".target")).newInstance());
			bean=pfb.getProxy();
		}
		return bean;
	}
}

class ProxyFactoryBean{
	private Advice advice;
	private Object target;
	public Advice getAdvice(){
		return advice;
	}
	public void setAdvice(Advice advice){
		this.advice=advice;
	}
	public Object getTarget(){
		return target;
	}
	public void setTarget(Object target){
		this.target=target;
	}
	public Object getProxy(){
		Object proxy=Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				new InvocationHandler(){
					@Override
					public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
						advice.beforeFunction(proxy,method,args);
						Object retVal=method.invoke(target,args);
						advice.afterFunction(proxy,method,args);
						return retVal;
					}
				}
				);
		return proxy;
	}
}

class MyAdvice implements Advice{
	private long startTime=0;
	private long endTime=0;
	@Override
	public void beforeFunction(Object proxy,Method method,Object[] args){
		//System.out.println("方法 "+method.getName()+ "调用前");
		startTime=System.currentTimeMillis();
	}

	@Override
	public void afterFunction(Object proxy,Method method,Object[] args){
		//System.out.println("方法 "+method.getName()+ "调用后");
		endTime=System.currentTimeMillis();
		System.out.println("方法执行用时:"+(endTime-startTime)+" 毫秒");
	}
}

public class MiniSpringTest{
	public static void main(String[] args)throws Exception{
		InputStream is=MiniSpringTest.class.getResourceAsStream("config.properties");
		Object bean=new BeanFactory(is).getBean("TTT");
		System.out.println(bean.getClass().getName());
	}
}

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

详细请查看： http://edu.csdn.net/heima