---------android培训、java培训、期待与您交流！ ----------
一，java基础加强
1.反射(reflect)技术：把java类中的各种成分映射成相对应的java类
①反射类：Class
Class clazz = Class.forName("类全名");//加载类，获得类的字节码，也可以通过类型.class获得
//取得类的构造函数，getConstructor()可以带多个参数(与类的构造函数列表对应）
Constructor constructor = clazz.getConstructor(Object.class...);
//通过取得的构造函数来实例化类，newInstance()可以按指定参数来 要实例化的那个类
//由于newInstance()返回的类型是Object，所以还需要强制转换。这样就可以把对应的类反射出来了
Person p = (Person) constructor.newInstance();
//Person p = constructor.getDeclaredConstructor();//若类的构造函数私有，可以使用暴力反射获取
//constructor.setAccessible(true); 强制访问
②反射方法：Method
Method method = 类的字节码.getMethod("方法名","参数列表...");//以方法名和参数来获得类的方法
method.invoke("操作所属的类对象","参数列表");//method的invoke()方法可以操作指定对象、参数的方法
//如果第一个参数为null，则该对应方法是静态方法
//若类方法私有，也可以用暴力反射来获取，method.getDeclaredMethod("对象","参数列表")
//method.setAccessible(true);
③反射字段：Field
Field f = 类的字节码.getField("字段名")；//指定字段名
String name =f.getClass().get("操作所属对象")；
//若类属性私有，还可以用暴力反射来获取，f.getDeclaredMethod("对象")
//f.setAccessible(true);
④反射数组：main方法
String className = args[0];
Method mainMethod = Class.forName(className).getMothod("main",String[].class)
mainMethod.invoke(null，(Object)new String[] {"abc","bcd","efg"} );
⑤反射的作用：主要用来实现框架的功能，在反射中不会显式new实例，用到的类名都需要从配置文件中读出来操作。
InputStream ins = new FileInputStream("config.properties");//用到的配置文件可放在和项目同一个目录下
Properties p = new Properties();
p.load(ins); //加载属性
ins.close(); //用完就关闭流
StringclassName= p.getProperty("配置文件中的属性名");//拿到属性值
//使用面向接口编程思想，获得对应类的实例后，可以进行具体的操作了
Collection collection = (Collection)Class.forName(className).newInstance();
.......
//反射其实就是加载一个类、解剖一个类，但因为它有缓存，所以对性能会有一定的影响
2.内省(IntroSpactor)：主要对JavaBean进行操作
①JavaBean是一个特殊的类，它拥有get/set属性的方法，判断一个类是否是JavaBean可以依据该类是否具有get/set方法
②JavaBean的简单内省操作：
Studentstu = new Student();
PropertyDescriptor pd = new PropertyDescriptor("类的属性名",stu.getClass());
Method getMethod = pd.getReadMethod();//JavaBean的get方法获取对象的get方法
Method setMethod = pd.getWriteMethod();//JavaBean的set方法获得对象的set方法
Object obj = getMethod.invoke(stu);//注意操作所属的对象
setMethod.invoke(stu,"设置值");
③使用BeanUtils工具包操作JavaBean：
BeanUtils工具包由apache提供，使用BeanUtils需要导入Comment-beanutils.jar包和comments-logging-1.1.jar包，使用BeanUtils主要有两个好处：属性类型自动转换、支持多属性操作(支持多级设置)，例：
BeanUtils.getProperty("对象"，"属性名"); //获得属性的get方法
BeanUtils.setProperty("对象"，"属性名(属性.属性.属性)"，“值”); //设置属性的set方法
3.注解(JDK1.5新特性)
①注解是一个类，相当于一种标记，它会向编译器传送一种信息，可验证程序的错误，用处：加在类上/方法上/变量上...
②supperessWarnings("deprecation")：告诉编译器使用过期方法
③Deprecated：可以设置某个方法过期
④override：在方法前使用可以判断该类是否覆写了父类的方法
⑤注解和反射：反射可以为注解添加各种属性
4.泛型(JKD1.5后的特性)
①泛型的通配符： ?(占位符) 、 ? extends T(上限，?类型必须是T的子类或T) 、? super T(下限，?必须是T的父类或T)
②自定义泛型：
自定义泛型类：public Person<T>{...} ,T类型在整个类中有效，类中可以不单单是T这种类型.
自定义泛型方法：<U> void show(U u){...}，U在方法内都有效，如果该方法是静态的，那么必须在方法上声明泛型
③反射和泛型：
在程序编译后，可以用反射向泛型加入其他类型的数据；
反射可以获得泛型的实际参数；
泛型的类型不能是基本数据类型，而是引用类型。
5.类加载器(ClassLoader)
①类加载器专门是加载类的工具，它也是一个java类，它也需要被加载，那么必须有一个最底层的加载器(BootStrap)
②类加载器的继承关系：从上到下，子类到父类
AppClassLoader--->加载ClassPath指定是所有jar或目录
ExtClassLoader---->加载JRE/lib/ext/*.jar
BootStrap()---->加载JRE/lib/rt.jar
③类加载器的委托机制：
AppClassLoader委托父类ExtClassLoader再委托父类BootStrap，所以类加载的顺序是：
先从BootStrap加载--若未找到-->ExtClassLoader加载--若未找到-->AppClassLoader加载--若未找到-->抛异常
④自定义类加载器：步骤是，自定义类继承ClassLoader，并实现FindClass()方法
⑤类加载器的高级分析：Servlet的类加载器
创建Servlet类的子类MyServlet，在doGet()方法中获得Servlet的类加载器：
ClassLoader loader = this.getClass().getClassLoader();
while(loader != null ){
out.println(loader.getClass().getName()+"\n");
loader = loader.getParent();
}
....
6.代理(Proxy)
①概念：为程序中已存在的功能添加新的功能，就是使用代理
②代理的特点：代理类的每个方法与目标类的方法相同
③代理涉及的三要素：要代理的对象，代理对象的方法，方法接受的参数
class Proxy{
add (Object obj){
return handler.invoke(Object proxy,Method method,Object[] args);
}
}
④实现代理的方法：
main：
Collection proxy = (Collection)Proxy.newProxyInstance(
Collection.class.GetClassLoader(); //第一个参数为类加载器
new Class[]{Collection.class}; //第二个参数为得到要操作的类型数组
new InvocationHander(){ //第三个参数为实现InvocationHander的子类
ArrayList target = new ArrayList();
public Object invoke(Object proxy,Method method,Object[] args){
Object retVal = method.invoke(target,args);
return retVal;
}
}
);
⑤生成代理和加入通告步骤：
首先将实现代理的代码抽取到getProxy()方法中，
public static void Object getProxy(final Objecttarget,finalAdvice advice){ //Advice为自定义的接口
Object proxy = Proxy.newProxyInstance(
target.class.GetClassLoader(); //得到目标类加载器
advice.getClass().getInterfaces()；//通告
new InvocationHander(){ //实现InvocationHander的子类
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
advice.beforeMethod(method);
Object retVal = method.invoke(target,args);
advice.afterMethod(method);
return retVal;
}
}
);
return proxy;
}
然后自定义一个Advice接口，编写两个抽象方法：beforeMethod()、afterMethod();
接着自定义一个MyAdvice类实现Advice接口并实现起抽象方法，在方法中可写需要代理的代码
最后main调用：
ArrayList target = new ArrayList();
Collection proxy = (Collection)getProxy( target, newMyAdvice());
proxy.add("abc"); proxy.add("123"); //添加数据会自动调用InvocationHander
System.out.println(proxy.size()); //查看数据
System.out.println(proxy.getClass().getName());
⑥实现类似Spring的可配置AOP框架
class BeanFactory{ //Bean工厂专门负责创建JavaBean对象
Properties props = new Properties();
public BeanFactory(InputStream in){ try：props.load(is); catch：Exception e }
public Object getBean(String name){
String className = props.getProperties(name);
Object bean = null;
try: Class clazz = Class.forName(className);
bean = clazz.newInstance();
catch:Exception e
if(bean instanceof ProxyFactoryBean){
ProxyFactoryBean pfb =(ProxyFactoryBean)bean;
try: Advice advice = (Advice)Class.forName(props.getProperty(name+".advice")).newInstance();
Object target = Class.forName(props.getProperty(name+".target")).newInstance();
pfb.setAdvice(advice);
pfb.setTarget(target);
proxy = pfb.getProxy();
returnproxy;
}
}
}
class ProxyFactoryBean{
private Advice advice;
private Object target;
public Object getProxy(){
Object proxy = Proxy.newProxyInstance(
target.class.GetClassLoader(); //得到目标类加载器
advice.getClass().getInterfaces()；//通告
new InvocationHander(){ //实现InvocationHander的子类
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
advice.beforeMethod(method);
Object retVal = method.invoke(target,args);
advice.afterMethod(method);
return retVal;
}
}
);
return proxy;
}
}
测试AOP框架
class AOPframework{
main:
//获得配置文件的信息，然后使用Bean工厂来操作代理
InputStream ins =AOPframework.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ins).getBean("xxx");
System.out.println(bean.getClass().getName());
}
---------android培训、java培训、期待与您交流！ ----------