您的位置:首页 > 职场人生

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

2012-10-21 00:36 288 查看
 ---------android培训java培训、期待与您交流!
----------    

 

一,java基础加强

     
1.反射(reflect)技术:把java类中的各种成分映射成相对应的java类


           ①反射类:Class

                        Class  clazz = Class.forName("类全名");//加载类,获得类的字节码,也可以通过类型.class获得

                        //[b]取得类的构造函数,getConstructor()可以带多个参数(与类的构造函数列表对应)[/b]

                        Constructor  constructor = clazz.getConstructor(Object.class...);    

                       [b]//通过取得的构造函数来实例化类,newInstance()可以按指定参数来 要实例化的那个类[/b]

[b]                        //由于newInstance()返回的类型是Object,所以还需要强制转换。这样就可以把对应的类反射出来了      [/b]

                       Person  p  = (Person) constructor.newInstance();  

                       //Person  p = constructor.getDeclaredConstructor();[b]//若类的构造函数私有,可以使用暴力反射获取[/b]

                      //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("操作所属对象");[b] [/b]

                      [b]//若类属性私有,还可以用暴力反射来获取,f.getDeclaredMethod("对象")[/b]

                      //f.setAccessible(true);

         ④反射数组:main方法

                      String className = args[0];

[b]                      Method  mainMethod  = Class.forName(className).getMothod("main",String[].class)[/b]

[b]                      mainMethod.invoke(null,(Object)new String[] {"abc","bcd","efg"} );[/b]

[b]         ⑤反射的作用:主要用来实现框架的功能,在反射中不会显式new实例,用到的类名都需要从配置文件中读出来操作。[/b]

                      InputStream ins = new FileInputStream("config.properties");//用到的配置文件可放在和项目同一个目录下

                      Properties  p = new Properties();

                      p.load(ins);        //加载属性

                      ins.close(); //用完就关闭流

                      String[b]className= p.getProperty("配置
4000
文件中的属性名");//拿到属性值[/b]

                      //使用面向接口编程思想,获得对应类的实例后,可以进行具体的操作了

                      Collection  collection = (Collection)Class.forName(className).newInstance();

                      .......

                           //反射其实就是加载一个类、解剖一个类,但因为它有缓存,所以对性能会有一定的影响

 

      2.内省(IntroSpactor):主要对JavaBean进行操作

           [b]①JavaBean是一个特殊的类,它拥有get/set属性的方法,判断一个类是否是JavaBean可以依据该类是否具有get/set方法[/b]

           [b]②JavaBean的简单内省操作:[/b]

                         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,"设置值");         

          [b]③使用BeanUtils工具包操作JavaBean:[/b]

[b]                  BeanUtils工具包由apache提供,使用BeanUtils需要导入Comment-beanutils.jar包和comments-logging-1.1.jar包,使用BeanUtils主要有两个好处:属性类型自动转换、支持多属性操作(支持多级设置),例:[/b]

                  BeanUtils.getProperty("对象","属性名");    //获得属性的get方法

                  BeanUtils.setProperty("对象","属性名(属性.属性.属性)",“值”);   //设置属性的set方法

[b]                     [/b]

      3.注解(JDK1.5新特性)

          [b]①注解是一个类,相当于一种标记,它会向编译器传送一种信息,可验证程序的错误,用处:加在类上/方法上/变量上...[/b]

[b]          [b]②supperessWarnings("deprecation"):告诉编译器使用过期方法[/b][/b]

[b][b]         [b]③Deprecated:可以设置某个方法过期[/b][/b][/b]

          [b][b]④override:在方法前使用可以判断该类是否覆写了父类的方法[/b][/b]

[b]          [b]⑤注解和反射:反射可以为注解添加各种属性[/b][/b]

      4.泛型(JKD1.5后的特性)

          [b]①泛型的通配符:  ?(占位符)  、 ?  extends T(上限,?类型必须是T的子类或T) 、? super T(下限,?必须是T的父类或T)[/b]

[b]         [b]②自定义泛型:[/b][/b]

[b][b]                   自定义泛型类:public Person<T>{...} ,T类型在整个类中有效,类中可以不单单是T这种类型.[/b][/b]

[b][b]                   自定义泛型方法:<U> void show(U u){...},U在方法内都有效,如果该方法是静态的,那么必须在方法上声明泛型[/b]      [/b]

         [b]③反射和泛型:[/b]

[b]                   在程序编译后,可以用反射向泛型加入其他类型的数据;[/b]

[b]                   反射可以获得泛型的实际参数;[/b]

[b]                   泛型的类型不能是基本数据类型,而是引用类型。[/b]

 

      5.类加载器(ClassLoader)

              [b]①类加载器专门是加载类的工具,它也是一个java类,它也需要被加载,那么必须有一个最底层的加载器(BootStrap)[/b]

[b]             [b]②类加载器的继承关系:从上到下,子类到父类[/b][/b]

[b][b]                      AppClassLoader--->加载ClassPath指定是所有jar或目录[/b][/b]

[b][b]                      ExtClassLoader---->加载JRE/lib/ext/*.jar[/b][/b]

[b][b]                      BootStrap()---->加载JRE/lib/rt.jar[/b][/b]

[b][b]             [b]③类加载器的委托机制[/b]:[/b][/b]

                     AppClassLoader委托父类ExtClassLoader再委托父类BootStrap,所以类加载的顺序是:

                     先从BootStrap加载--若未找到-->ExtClassLoader加载--[b]若未找到-->AppClassLoader加载--若未找到-->抛异常                 [/b]

[b]             ④自定义类加载器:步骤是,自定义类继承ClassLoader,并实现FindClass()方法[/b]

[b]             ⑤类加载器的高级分析:Servlet的类加载器[/b]

                    创建Servlet类的子类MyServlet,在doGet()方法中获得Servlet的类加载器:

                     ClassLoader loader = this.getClass().getClassLoader();

                     while(loader != null ){

                           out.println(loader.getClass().getName()+"\n");

                           loader = loader.getParent();

                     }      

                     ....  

      6.代理(Proxy)  

[b]             ①概念:为程序中已存在的功能添加新的功能,就是使用代理[/b]

             [b]②代理的特点:代理类的每个方法与目标类的方法相同[/b]

             [b]③代理涉及的三要素:要代理的对象,代理对象的方法,方法接受的参数[/b]

                    class  Proxy{

                            add (Object obj){

                                  return handler.invoke(Object proxy,Method method,Object[] args);

                            }

                    }

 

[b]            [b]④实现代理的方法:[/b][/b]

                    main:

                             Collection proxy = (Collection)Proxy.newProxyInstance(

                                      Collection.class.GetClassLoader(); //第一个参数为类加载器

                                      new Class[]{Collection.class}; //第二个参数为得到要操作的类型数组

                                      new InvocationHander(){    //第三个参数为实现InvocationHander的子类

                                         [b]ArrayList target = new ArrayList();[/b]

                                          public Object invoke(Object proxy,Method method,Object[] args){

                                               [b]Object retVal = method.invoke(target,args);[/b]

                                                return retVal;

                                          } 

                                      }

                             );

 

             ⑤生成代理和加入通告步骤:

                   首先将实现代理的代码抽取到getProxy()方法中,

                   public static void Object getProxy(final Objecttarget,finalAdvice advice){ //Advice为自定义的接口

                         [b]Object  proxy = Proxy.newProxyInstance([/b]

                                     target.class.GetClassLoader(); //得到目标类加载器

                                      advice.getClass().getInterfaces();//通告

                                      new InvocationHander(){    //实现InvocationHander的子类

                                         public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{

                                                 advice.beforeMethod(method);

                                                                                 [b]Object retVal = method.invoke(target,args);[/b]

                                                                                 advice.afterMethod(method);

                                                 return retVal;

                                          } 

                                      }

                             );

                      return proxy;

                   }

                  然后自定义一个Advice接口,编写两个抽象方法:beforeMethod()、afterMethod();

                  接着自定义一个MyAdvice类实现Advice接口并实现起抽象方法,在方法中可写需要代理的代码

                  最后main调用:

                      ArrayList  target = new ArrayList();

                      Collection  proxy = (Collection)getProxy( target, new[b]MyAdvice());[/b]

                      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();

                                    [b]Object  target = Class.forName(props.getProperty(name+".target")).newInstance();[/b]

                                    pfb.setAdvice(advice);

                                    pfb.setTarget(target);

                                    proxy = pfb.getProxy();

                                 return[b]proxy;[/b]

                               }      

                           }

                     }

           class  ProxyFactoryBean{

               private Advice advice;

               private Object target;

               public Object getProxy(){

                       [b]Object  proxy = Proxy.newProxyInstance([/b]

                                      target.class.GetClassLoader(); //得到目标类加载器

                                      advice.getClass().getInterfaces();//通告

                                      new InvocationHander(){    //实现InvocationHander的子类

                                         public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{

                                                 advice.beforeMethod(method);

                                                                                 [b]Object retVal = method.invoke(target,args);[/b]

                                                                                 advice.afterMethod(method);

                                                 return retVal;

                                          } 

                                      }

                             );

                      return proxy;

              }

           } 

         测试AOP框架

                  class AOPframework{

                        main:

                               //获得配置文件的信息,然后使用Bean工厂来操作代理

                               InputStream  ins =[b]AOPframework.class.getResourceAsStream("config.properties");[/b]

                               Object  bean = new BeanFactory(ins).getBean("xxx");

                               System.out.println(bean.getClass().getName());

                 }

     

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

 
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: