精华内容
下载资源
问答
  • 仿照现在项目中的例子,写了一个用注解和反射封装起来的,专门用于绑定事件的id和点击事件的demo,不用每次都去findviewbyid了,属于懒人的一个方法吧。。。。
  • java 反射机制

    2015-08-12 10:04:36
    java反射机制就是在运行状态中动态的知道任意一个类的属性和方法,对于任意一个对象能调用它的方法。 这个机制具有的功能有:  能构造任意一个类的对象并且相应的能判断...1.判断对象是否属于反射的类 public cl

    java反射机制就是在运行状态中动态的知道任意一个类的属性和方法,对于任意一个对象能调用它的方法。

    这个机制具有的功能有:

           能构造任意一个类的对象并且相应的能判断任意一个对象所属的类

           能得出任意一个类中的属性和方法

           能调用任意一个对象中的方法

           动态代理的组成部分


    例子:

    1.判断对象是否属于反射的类

    public class test {
      public static void main(String args[]) throws ClassNotFoundException {   
              Class c = Class.forName("test");   
              System.out.println(c.isInstance(new String()));   
              System.out.println(c.isInstance(new test()));   
          }
    }

    这就是有一个test类,然后用创建一个test类对象,new一个string和一个test分别去对比,输出为false和true


    2.获取任意一个类的所有属性

    public class test {
    private String name ;
    private long password;
      public static void main(String args[]) throws Exception {   
              Class c = Class.forName("test");   
              getProperty(c);
          }
      
      public static Field[] getProperty(Class c) throws Exception {  
       //获取该类所有属性字段  
       //Field[] fields = c.getFields();//只获取public访问权限的属性字段(包括父类的)  
       Field[] fields = c.getDeclaredFields();//只获取该类的所有访问权限的属性(不含父类)  
       for(int i=0;i<fields.length;i++){  
           System.out.println("属性:"+fields[i]);  
       }  
       return fields;  
    }

    }

    输出结果:

    属性:private java.lang.String test.name
    属性:private long test.password


    3.获得对象的特定public属性的值

    public static Object getProperty(Object owner,String fieldName) throws Exception {  
       //得到对象所属类  
       Class ownerClass = owner.getClass();  
       //获取该类的某个属性  
       Field field = ownerClass.getField(fieldName);  
       //获取某个对象的特定属性  
       Object property = field.get(owner);  
       //输出该属性信息  
       System.out.println(fieldName+"的属性值:"+property.toString());  
       return property;  
    }  


    4.获得对象中的方法,执行对象中的方法

    public Method[] getMethods(Class c) throws Exception {  
       //获取该类所有方法  
       //Field[] fields = ownerClass.getMethods();//只获取public访问权限的方法(包括父类的)  
       Method[] methods = c.getDeclaredMethods();//只获取该类的所有访问权限的方法(不含父类)  
       //输出所有方法  
       for(int i=0;i<methods.length;i++){  
           System.out.println("方法:" +methods[i]);  
       }  
       return methods;  
    }  

    public Object invokeMethod(Object owner,String methodName,Object[] args) throws Exception {  
       //得到对象所属类  
       Class ownerClass = owner.getClass();  
       //获取该类的某个方法  
       Method method = ownerClass.getMethod(methodName, null);  
       //执行某个对象的方法  
       Object result = method.invoke(owner, args);  
       //输出结果信息  
       System.out.println("结果返回值:"+ result);  
       return result;  
    }  

    展开全文
  • Java反射总结

    2014-01-24 14:09:47
    下面我们用一个特别实际的例子来了解一下 l Person类代表人,它的实例对象就是张三,李四这样一个个具体的人, Java程序中的各个Java类属于同一类事物,描述这类事物的Java类名就是Class。对比提问:众多的人...

    学习了反射,为了更加深入的了解反射的知识,下面我对反射的知识点进行一次小结

    一、反射的基石为class

    下面我们用一个特别实际的例子来了解一下

    l

    Person类代表人,它的实例对象就是张三,李四这样一个个具体的人, Java程序中的各个Java类属于同一类事物,描述这类事物的Java类名就是Class。对比提问:众多的人用一个什么类表示?众多的Java类用一个什么类表示?

    Ø       人-->Person

    Ø       Java类-->Class

    我们在定义一个普通的Person对象的时候是这样来实现的

    Person p1 = new Person();

    Person p2 = new Person();

    但是如果我们想定义一个class对象是不是也可以像这样扶植呢?

    Class cls1 = new Class();?这里我给出答案,是不能这样写的,在java里,是不允许这样赋值的的,同样也没有这种赋值的写法

    那么我们该如何来实现呢?

    我们来通过字节码来实现,如下

    Class cls1 = 字节码;

    那么什么是字节码呢?每一个字节码都是一个class的对象

    如果说这里有三个对象,分别是:Person,Math,Date

    那么我们就可以用字节码来实现

    Class cls1 = Date.class;//Date.class代表Date类得字节码

    Class cls2 = Person.class;//Person.class代表Person类得字节码

     

    那么又是如何得到各个字节码对应的实例对象

     

    Ø

    Ø     类名.class,例如,System.class

    Ø    对象.getClass(),例如,new Date().getClass()

    Ø    Class.forName("类名"),例如,Class.forName("java.util.Date");//做反射的时候做多使用第三种

     

    现在可以说是该了解的都已经了解了,那么我们来通过一个小的程序段来更好的了解反射

    package cn.itcast.day1;

    import java.lang.reflect.Constructor;

    public class ReflectTest {

     
     public static void main(String[] args) throws Exception
     {
      String str1 = "abc";
      Class cls1 = str1.getClass();
      Class cls2 = String.class;
      Class cls3 = Class.forName("java.lang.String");
      System.out.println(cls1 == cls2);
      System.out.println(cls1==cls3);
      
      System.out.println(cls1.isPrimitive());//isPrimitive 判定指定的 Class 对象是否表示一个基本类型。打印结果为:false
      System.out.println(int.class.isPrimitive());//输出结果为:true
      System.out.println(int.class==Integer.class);//输出结果为false
      System.out.println(int.class==Integer.TYPE);//TYPE表示基本类型 int 的 Class 实例,输出结果为:true
      System.out.println(int[].class.isPrimitive());//输出结果为:false
      System.out.println(int[].class.isArray());//isArray判定此 Class 对象是否表示一个数组类。输出结果为:true
      
      Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
      String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
      //String str2 = (String)constructor1.newInstance("abc");Exception in thread "main" java.lang.IllegalArgumentException: argument type mismatch
      System.out.println(str2.charAt(2));//输出abc中的第二个字符,输出结果为c
     }

    }

     

    l       数组类型的Class实例对象

    Ø       Class.isArray()

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

     


    二、反射的概念

     反射就是把Java类中的各种成分映射成相应的java类。

     

    例如,一个Java类中用一个Class类的对象来表示,一个类中的组成部分:成员变量,方法,构造方法,包等等信息也用一个个的Java类来表示,就像汽车是一个类,汽车中的发动机,变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符,包等信息,这些信息就是用相应类的实例对象来表示,它们是Field、Method、Contructor、Package等等。

    三、Constructor类 

    1、Constractor代表某个类中的一个构造方法

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

    例子:Constructor[] constructors=

    Class.forName("java.lang.String").getConstructors();

    3、得到某一个构造方法

    例子:Constructor constructor=

    Class.forName("java.lang.String").getConstructor(StringBuffer.class);//获得方法时要用到类型

    4、创建实例对象

    例子:

    通常方式:String str = new String(new StringBuffer("abc"));

    反射方式:String str =(String)constructor.newInstance(new StringBuffer("abc"));//调用获得的方法时要用到上面相同类型的实例对象

    5、Class.newInstance()方法:

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

    该方法内部先得到默认的构造方法,然后用构造方法创造实例对象。

    6、下面是我们关于一个Constructor的具体实例

    package cn.itcast.day1;

    import java.lang.reflect.Constructor;

    public class ConstructorTest
    {

     
     public static void main(String[] args)throws Exception
     {
      String str ="abc";
      Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
      String str1 = (String)constructor1.newInstance(new StringBuffer("abc"));//我们可以在constructor1方法身上,调用好多次这个方法,每调用一次,就是new了一个新的方法
      System.out.println(str1.charAt(2));
     }

    }

    四、Field类

    1、Field代表某个类中的一个成员变量

    2、下面我们先来看一个关于Field类得例子

    package cn.itcast.day1;

    import java.lang.reflect.Field;

    public class RefectPointTest {

     
     public static void main(String[] args)throws Exception
     {
      RefectPoint rf = new RefectPoint(3,5);
      Field fieldY = rf.getClass().getField("y");
      //fieldY的值是多少?5?错!fieldY不是对象身上的变量,而是类上的,要用它去取某个对象上对应的值
      
      System.out.println(fieldY.get(rf));
      
      Field fieldX = rf.getClass().getDeclaredField("x");//返回一个 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。name 参数是一个 String,它指定所需字段的简称。注意,此方法不反映数组类的 length 字段
      fieldX.setAccessible(true);//暴力反射
      System.out.println(fieldX.get(rf));
      changStringValue(rf);
      System.out.println(rf);
     }
     
     private static void changStringValue(Object obj)throws Exception
     {
      Field[] fields = obj.getClass().getFields();
      for(Field field:fields)
      {
       //field.getType().equals(String.class);
       if (field.getType()==(String.class))//比较同一份字节码要用等号
       {
        String OldValue = (String)field.get(obj);
        String NewValue = OldValue.replace('b', 'a');
        field.set(obj, NewValue);
       }
      }
     }

    }
    五、Method类

    1、Method类代表某个类中的一个成员变量

    2、得到类中的某一个方法:

    例子:Method charAt=

    Class.forName("java.lang.String").getMethod("charAt",int.class);

    3、调用方法

    通常方法:System.out.println(str.charAt(1));

    反射方法:System.out.println(charAt.invoke(str,1));

    如果传递给Method方法的invoke()方法的第一个参数为null,这有着什么样的意义呢?说明该Method对象对应的是一个静态方法!

    4、下面是一个Method类的例子

    package cn.itcast.day1;

    import java.lang.reflect.Method;

    public class MethodTest {

     
     public static void main(String[] args) throws Exception
     {
      String str1 = "abc";
      Method methodCharAt = String.class.getMethod("charAt", int.class);
      System.out.println(methodCharAt.invoke(str1, 1));
      
      System.out.println(methodCharAt.invoke(str1, new Object[]{2}));
     }

    }
    六、用反射方式执行类中的某个main方法

    关于这个问题我们直接用一个案例来理解

    package cn.itcast.day1;

    import java.lang.reflect.Method;

    public class MainTest {

     
     public static void main(String[] args)throws Exception
     {
      //TestArguments.main(new String[]{"111"});//这就是在程序里面用静态代码的方式直接调用他的main方法
      //以下是用反射的方式是实现
      String startingClassName = args[0];
      Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
      //张老师提供的方法
      //mainMethod.invoke(startingClassName, new Object[]{new String[]{"111","222","333"}});
      //李老师提供的方法是:
      mainMethod.invoke(startingClassName, (Object)new String[]{"111","222","333"});
     }
     
    }
    class TestArguments
    {
     public static void main(String[] args)
     {
      for(String arg:args)
      {
       System.out.println(arg);
      }
     }
    }

    七、数组的反射

    一、这些是应该注意的细节

    1、具有相同维数和元素类型的数组属于同一个类型,即具有相同的Class实例对象。

    2、代表数组的Class实例对象的getSuperclass()方法返回的父类为Object类对应的Class。

    3、基本类型的一维数组可以被当做Object类型使用,不能当做Object[]类型使用;非基本类型的一维数组,既可以当做Object类型使用,又可以当做Object[]类型使用。

    好了,既然我们已经把细节了解的差不多了,那么我们就要用一个实例来把这些细节体现出来

    package cn.itcast.day1;

    import java.lang.reflect.Array;
    import java.util.Arrays;

    public class RefectArray {

     
     public static void main(String[] args)
     {
      int[] a1 =new int[]{1,2,3};
      int[] a2 = new int[4];
      int[][] a3 = new int[3][4];
      String [] a4 = new String[]{"abc","def","gi"};
      System.out.println(a1.getClass() == a2.getClass());
      System.out.println(a1.getClass() == a3.getClass());
      System.out.println(a1.getClass() == a4.getClass());
      System.out.println(a1.getClass().getName());
      System.out.println(a1.getClass().getSuperclass().getName());
      System.out.println(a4.getClass().getSuperclass().getName());
      
      Object aObj1 = a1;
      Object aObj2 = a2;
      //Object[] aObj3 = a1;//基本类型的一维数组可以被当作Object类型使用,不能当作Object[]类型使用
      Object[] aObj4 = a3;
      Object[] aObj5 = a4;
      
      System.out.println(a1);
         System.out.println(a4);
        
         System.out.println(Arrays.asList(a1));
         System.out.println(Arrays.asList(a4));
        
         Object obj = null;
         printObject(a4);
         printObject("xyz");
         printObject(a1);
     }

     private static void printObject(Object obj)
     {
      Class clazz = obj.getClass();
      if(clazz.isArray())
      {
       int len = Array.getLength(obj);
       for(int i = 0; i<len;i++)
       {
        System.out.println(Array.get(obj, i));
       }
       
      }
      else
      {
       System.out.println(obj);
      }
     }

    }
    好了,这些就是关于反射的一些知识点!!

    展开全文
  • Java反射机制

    2016-09-20 14:47:33
    举个例子,程序在运行时接收到外部传入一个对象,该对象编译时类型是Object,但程序又需要调用该对象运行时类型方法,编译时根本无法预知该对象和类可能属于哪些类,程序只能依靠运行时信息来发现该对象和类...

    为什么要使用反射?举个例子,程序在运行时接收到外部传入的一个对象,该对象的编译时类型是Object,但程序又需要调用该对象运行时类型的方法,编译时根本无法预知该对象和类可能属于哪些类,程序只能依靠运行时信息来发现该对象和类的真实信息,这时候就必须使用反射。

    Java反射机制主要提供了以下功能:

    在运行时判断任意一个对象所属的类;

    在运行时构造任意一个类的对象;

    在运行时判断任意一个类所具有的成员变量和方法;

    在运行时调用任意一个对象的方法,包括private修饰的方法

    Java反射所需要的类并不多,主要有java.lang.Class类,Java.lang.reflect包中的FieldConstructorMethodArray类,这里简单挑几个介绍一下。


    1.Class

    ClassReflection反射机制的起源,想要操作类的属性和方法,就必须从获取Class 对象开始,获取Class对象途径:

    1)使用类的class属性:

    Class<java.util.Date> clz1 = java.util.Date.class;

    2)通过Class类中的静态方法forName(String className),传入类的全限定名(必须添加完整包名)

    Class<?> clz3 = Class.forName(“java.util.Date”);

    3)通过对象的getClass方法来实现,其中,getClass()Object类中的方法,所有的对象都可以调用该方法

    java.util.Date str = new java.util.Date();

    Class<?> clz2 = str.getClass();


    2.Constructor

    Constructor:表示类中构造器的类型,Constructor的实例就是某一个类中的某一个构造器

    Class类获取构造器方法:

    public Constructor<?>[] getConstructors():

    该方法只能获取当前Class所表示类的public修饰的构造器

    public Constructor<?>[] getDeclaredConstructors():

    获取当前Class所表示类的所有的构造器,和访问权限无关

    public Constructor<T> getConstructor(Class<?>... parameterTypes) :

    获取当前Class所表示类中指定的一个public的构造器

    参数:parameterTypes表示:构造器参数的Class类型

     

    Constructor常用方法:

    public T newInstance(Object... initargs):如调用带参数的构造器,只能使用该方式.

         参数:initargs:表示调用构造器的实际参数

         返回:返回创建的实例,T表示Class所表示类的类型

     

    如果一个类中的构造器是外界可以直接访问,同时没有参数.,那么可以直接使用Class类中的newInstance方法创建对象.

     public Object newInstance():相当于new 类名();

     

    调用私有的构造器:

    访问私有的成员的时候,必须先设置可访问的:

    对象.setAccessible(true);

    调用私有构造器也一样,要先设置可访问:

    构造器对象.setAccessible(true);

     

    总的来说,使用反射创建对象的步骤如下:

        1);找到构造器所在类的字节码对象,即上述的Class对象.

        2):获取构造器对象.

        3):使用反射,创建对象

     

    3.Method

    使用反射获取类中的方法:

    1):获取方法所在类的字节码对象.

    2):获取方法.

     

    Class类中获取Method的常用方法:

    1public Method[] getMethods():获取包括自身和继承过来的所有的public方法

    2public Method[] getDeclaredMethods():获取自身类中所有的方法(不包括继承的,和访问权限无关)

     

    3public Method getMethod(String methodName,Class<?>... parameterTypes):表示调用指定的一个公共的方法(包括继承的)

           参数:

                   methodName: 表示被调用方法的名字

                   parameterTypes:表示被调用方法的参数的Class类型如String.class

     

    4public Method getDeclaredMethod(String name,Class<?>... parameterTypes):表示调用指定的一个本类中的方法(不包括继承的)

            参数:

                   methodName: 表示被调用方法的名字

                   parameterTypes:表示被调用方法的参数的Class类型如String.class

     

    使用反射调用方法的步骤:

    1):获取方法所在类的字节码对象.

    2):获取方法对象.

    3):使用反射调用方法.

     

    如何使用反射调用一个方法:

    Method类中有这样一个方法可以实现这个功能:

    public Object invoke(Object obj,Object... args):表示调用当前Method所表示的方法

          参数:

                obj: 表示被调用方法底层所属对象

                     Method m = clz.getMethod("sayHi",String.class);

                args:表示调用方法是传递的实际参数

          返回:

                底层方法的返回结果

     

    如果是要调用私有方法,在调用之前要设置该方法为可访问的:

    Method对象.setAccessible(true);

     

    扩展:

    1)使用反射调用静态方法:

       静态方法不属于任何对象,静态方法属于类本身.

       此时把invoke方法的第一个参数设置为null即可.




    2)使用反射调用数组参数(可变参数):

       调用方法的时候把实际参数统统作为Object数组的元素即可.

       Method对象.invoke(方法底层所属对象,new Object[]{  所有实参   });

    class Student{
    	public static void doWork1(int... arr ){
    		System.out.println("doWork1方法被调用"+Arrays.toString(arr));
    	}
    	
    	public static void doWork2(String...strings){
    		System.out.println("doWork2被调用"+Arrays.toString(strings));
    	}
    }
    
    //使用反射调用数组参数(可变参数):
    public class MethodInvokeDemo {
    	public static void main(String[] args) throws Exception {
    		Class<?> clz1 = Student.class;
    		//情况1:数组的元素类型是基本类型
    		Method m = clz1.getMethod("doWork1", int[].class);
    		//m.invoke(null, 1,2,3,4,5);//错误
    		System.out.println(m);
    		//m.invoke(null, new int[]{1,2,3,4,5,6});//正确,也可以改成下面的
    		m.invoke(null, new Object[]{new int[]{1,2,3,4,5,6}});//正确
    		
    		//情况2:数组的元素类型是引用类型
    		m = clz1.getMethod("doWork2",String[].class);
    		//m.invoke(clz1.newInstance(),  new String[]{"A","b","C"});报下面的异常
    		//java.lang.IllegalArgumentException: wrong number of arguments
    		m.invoke(clz1.newInstance(), new Object[]{new String[]{"A","b","C"}});//正确
    	}
    
    }



    展开全文
  • Java反射与动态代理

    2017-03-23 17:36:00
    Java反射与动态代理 1.Java反射 当通过反射与一个未知类型的对象打交道时,JVM只简单地检查这个对象,看它属于哪个特定的类。...下面就是一个反射的例子,通过反射输出了该类的所有方法和构造器,然...

    Java反射与动态代理

    1.Java反射

    当通过反射与一个未知类型的对象打交道时,JVM只简单地检查这个对象,看它属于哪个特定的类。在用它做其他事情之前必须先加载那个类的Class对象。

    当使用反射时,就可以在运行时获取类信息,对于反射机制来说,.class文件在编译时是不可获取的,所以是在运行时打开和检查.class文件。

    下面就是一个反射的例子,通过反射输出了该类的所有方法和构造器,然后通过反射调用了该类的方法。从输出结果可以看出,通过反射获取到了运行类的所有方法信息和构造函数信息,还通过反射机制调用了该类的方法,进行了输出。

    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.regex.Pattern;
    
    public class ShowMethods {
        private static String usage = "usage";
        private static Pattern p = Pattern.compile("\\w+\\.");
    
        public void method1() {
            System.out.println("我被调用啦");
        }
    
        public void method2(int num) {
            System.out.println(num);
        }
    
        public static void main(String[] args) {
            try {
                ShowMethods showMethods = new ShowMethods();
                System.out.println(showMethods.getClass().getName());
                // 加载该类
                Class<?> c = Class.forName("reflect.ShowMethods");
                // 获取该类所有的方法
                Method[] methods = c.getMethods();
                // 获取该类所有的构造函数
                Constructor[] constructors = c.getConstructors();
                for (Method method : methods) {
                    System.out.println(p.matcher(method.toString()).replaceAll(" "));
                }
                for (Constructor constructor : constructors) {
                    System.out.println(p.matcher(constructor.toString()).replaceAll(" "));
                }
                // 获取该类的method1方法
                Method method1 = c.getMethod("method1");
                // 调用无参方法
                method1.invoke(c.newInstance());
                // 获取该类的method2方法
                Method method2 = c.getMethod("method2", int.class);
                // 调用有参方法,传入参数20
                method2.invoke(c.newInstance(), 20);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

     

    输出结果如下:

    reflect.ShowMethods
    public static void   main(  String[])
    public void   method1()
    public void   method2(int)
    public final void    wait() throws   InterruptedException
    public final void    wait(long,int) throws   InterruptedException
    public final native void    wait(long) throws   InterruptedException
    public boolean    equals(  Object)
    public   String    toString()
    public native int    hashCode()
    public final native   Class    getClass()
    public final native void    notify()
    public final native void    notifyAll()
    public  ShowMethods()
    我被调用啦
    20

     

    2.代理模式

    静态代理

    由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。

    Subject接口

    public interface Subject {
        void request();
    }

     

    RealSubject类

    public class RealSubject implements Subject {
        @Override
        public void request() {
            System.out.println("RealSubject");
        }
    }

     

    代理类

    public class Proxy implements Subject {
        private Subject subject;
    
        public Proxy(Subject subject) {
            this.subject = subject;
        }
    
        @Override
        public void request() {
            System.out.println("begin");
            subject.request();
            System.out.println("end");
        }
    }

     

    测试类

    public class ProxyTest {
        public static void main(String[] args) {
            RealSubject realSubject = new RealSubject();
            Proxy proxy = new Proxy(realSubject);
            proxy.request();
        }
    }

     

    动态代理

    动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成,所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

    同样实现上面的结构。

    public interface Subject {
        void doSomething();
    }
    public class RealSubject implements Subject {
        public void doSomething() {
            System.out.println("我正在做某事");
        }
    }

    代理类

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class SubjectProxy implements InvocationHandler {
        private Object target;
    
        public SubjectProxy(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("begin");
            Object result = method.invoke(target, args);
            System.out.println("end");
            return result;
        }
    
        public Object getProxy() {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            Class<?>[] interfaces = target.getClass().getInterfaces();
            return Proxy.newProxyInstance(classLoader, interfaces, this);
        }
    }
    public class SubjectTest {
        public static void main(String[] args) {
            RealSubject realSubject = new RealSubject();
            SubjectProxy subjectProxy = new SubjectProxy(realSubject);
            Subject subject = (Subject)subjectProxy.getProxy();
            subject.doSomething();
        }
    }

    优点:动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理。

    不足:始终无法摆脱仅支持 interface 代理的桎梏。

    转载于:https://www.cnblogs.com/alsf/p/6606341.html

    展开全文
  • 一 单例模式概述 (一) 什么是单例模式 单例模式属于创建型模式之一,它提供了一种创建对象的最佳方式 在软件工程中,创建型模式是处理对象创建的设计模式,试图根据实际情况使用合适的...顺便提一个很常见的例子:例
  • 反射的概念其实可以理解成根据类名返回该类的任何信息,比如该类有什么方法,参数,变量等等。我们先来学习下反射要用到的api。拿User举例 <pre><code>php // 获取User的reflectionClass对象 $...
  • 传统的工厂设计操作中会存在两个严重的问题: 问题1:传统工厂设计属于静态工厂设计,需要根据传入的参数并结合大量的分支语句...1、反射与工厂设计模式的例子: package com.mydemo; public class ReflectionMecha
  • 一 单例模式概述 (一) 什么是单例模式 单例模式属于创建型模式之一,它提供了一种创建对象的最佳方式 在软件工程中,创建型模式是处理对象创建的设计模式,试图根据实际情况使用合适的方式...顺便提一个很常见的例子.
  • 介绍: 同样,describeType也是属于flash.utils下工具方法。生成描述ActionScript对象xml对象。此方法实现Actionscript语言的反射编程概念。注意,参数value为实例对象。 生成xml例子: &lt;type name=&...
  • Java动态特性--反射

    2021-03-01 11:22:50
    提示:本文属于基础语法和例子,个人复习整理,用于备忘,谢谢!!!! 动态特性简介: Java中有一些动态特性,用来协助开发者在运行时编写出动态代码,实现更优质功能。比如反射、注解、动态代理、类加载器。...
  • 什么是单例模式?   单例模式(Singleton Pattern)是 Java 中最简单设计模式...这个类提供了一种访问其唯一对象方式(如下面例子LazyMan01.getInstance),可以直接访问,不需要实例化该类对象。 注意:...
  • java反射详解

    2012-09-21 14:32:53
    他们也会感到困惑与傍徨,但每个程序员心中都有一个比尔盖茨或是乔布斯梦想“用智慧开创属于自己事业”。我想说是,其实我是一个程序员。 本篇文章依旧采用小例子来说明,因为我始终觉,案例驱动是最好...
  • 我有一个保存/加载框架,该框架应该保存任意对象图....作为一个简单的例子,我介绍这个类:public class Foo implements Savable {private class Bar implements Savable {public void saveState(S...
  • 1、内置函数 isinstance() :判断对象所属类型,包括继承关系(例如下面例子,返回结果都是True) class A: pass class B(A): ...注意:== 表示是值相等,属于值运算 is 内存地址相等,属...
  • 反射跟接口结合在一起用情况比较多见,若接口到底是什么也没看明白,云里雾里反射你先别折腾了,浪费生命意义不大,折腾也是属于瞎搞了,还是踏实把接口仔细学学,多做几个例子巩固一下。  还没明白...
  • Java反射机制(1)

    2015-11-02 21:09:13
    Java程序中各个Java类属于同一类事物,描述这一类事物Java类名就是Class。 Class class1;中class1就是一份对应相关类型字节码; 获取该份字节码方式有以下三种(下面就以String为例子来作说明): 方式一: ...
  • 反射跟接口结合在一起用情况比较多见,若接口到底是什么也没看明白,云里雾里反射你先别折腾了,浪费生命意义不大,折腾也是属于瞎搞了,还是踏实把接口仔细学学,多做几个例子巩固一下。 还没明白接口,...
  • java注解属于java中高大上功能,许多开源框架都使用了java注解功能。比如spring,hibernate等等。 从几年前java1.5开始,java新增了泛型、注解、并发功能。这些功能都是java高大上功能。到现在还在广泛...
  • 广义反射矩阵是一类特殊矩阵,它们之间具有关系,并且是一些广义反射矩阵。 在许多科学和工程应用中... 数值例子说明了所开发显式分解对于将系数矩阵属于此类线性最小二乘问题解耦为较小且独立子问题有用性。
  • 利用VS生成时序图考虑时序图该画写什么

    万次阅读 热门讨论 2013-04-08 20:20:18
    为了研究时序图究竟如何画,自己写了个经典三层的登录小例子以及一个加上抽象工厂和反射的三层登录小例子,运用VS的生成时序图功能,将代码生成时序图,研究时序图究竟需要什么元素.由于VS生成的时序图,会将所有的If,Try...
  • 窃取Cookie实例中用到的XSS攻击模式,就属于反射型XSS。反射型XSS多发生于网页 将用户的输入值原封不动地显示出来的情况下。其中,输入值确认页面就是一个典型的例子 存储型XSS XSS产生的根源 XSS漏洞产生的原因...
  • 之前Hello World例子应该已经让我们对Emit...1.什么是反射发出(Reflection Emit)Emit应该是属于反射一个比较高级功能,说到反射大家应该都不陌生,反射是在运行时发现对象相关信息,并且执行这些对象(创建...
  • Hello World例子应该已经让我们对Emit有了一个模糊了解,那么Emit到底是什么样一个东西,他又能...Emit应该是属于反射一个比较高级功能,说到反射大家应该都不陌生,反射是在运行时发现对象相关信息,...
  • 之前Hello World例子应该已经让我们对Emit有了一个模糊了解,那么Emit到底是什么样一个东西,他又能...Emit应该是属于反射一个比较高级功能,说到反射大家应该都不陌生,反射是在运行时发现对象相关信...

空空如也

空空如也

1 2 3
收藏数 48
精华内容 19
关键字:

属于反射的例子