黑马程序员--java高新技术

最新推荐文章于 2014-12-10 19:02:28 发布

C_ontinue

最新推荐文章于 2014-12-10 19:02:28 发布

阅读量422

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/C_ontinue/article/details/8093410

本文深入探讨Java基础加强，包括反射技术、内省、注解、泛型、类加载器与代理等高级应用，详细解析了每个概念的核心功能与实践方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

---------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培训、期待与您交流！ ----------