精华内容
下载资源
问答
  • 十一结束了,盼望着的十一要做的事情...java反射:程序运行时,通过反射获取的所有属性和方法, 动态创建对象,调用对象的属性和方法。 二、Method 是位于java.lang.reflect包下 在java反射中 共有四种方法: ...

    十一结束了,盼望着的十一要做的事情也没有做成。有时候的预期和现实总是有些许的变故,Economic freedom--闲扯结束。今天,就简单点。

    一、定义

    java反射:程序运行时,通过反射获取类的所有属性和方法, 动态创建对象,调用对象的属性和方法。

    二、Method

            是位于java.lang.reflect包下
            在java反射中
            共有四种方法:
            1、getMethods();获得类的public类型方法
            2、getMethod(String name, params);获得类的特定方法
            name 参数指定的方法名字、params方法对应的参数
            3、getDeclaredMethods();获取类中所有方法(public、protected、default、private)
            4、getDeclaredMethod(String name, params);获得类的特定方法
            invoke(Object obj, Object arg[]);方法接收的参数必须为对象

    三、定义测试类

    package com.css.java.learning.massbag;
    
    public class AllMethod {
        /*定义两个私有属性
         */
        private String name;//测试属性获取
        private String sex;//测试获取所有私有属性
        /*定义一个有参,公有构造函数
         */
        public static String youcan(String aa){
            System.err.println("java通过反射操作方法:有参" + aa);
            return "success";
        }
        /*定义一个无参,公有构造函数
         */
        public static void wucan(){
            System.err.println("java通过反射操作方法:无参");
        }
    
        /*定义一个无参,私有构造函数
         */
        @SuppressWarnings("unused")
        private static void siyou(){
            System.err.println("java通过反射操作方法:私有");
        }
        /*测试私有属性调用和赋值
         */
        @SuppressWarnings("unused")
        private void shuxing(){
            System.err.println(name + "正在利用java反射调用私有属性");
        }
        /*测试私有属性调用和赋值
         */
        @SuppressWarnings("unused")
        private void allshuxingh(){
            System.err.println(name + sex);
        }
    
    }

    四、java反射技术的实现

    //通过反射操作方法
        public static void main(String[] args) {
            AllMethod test = new AllMethod();
            Class<?> allm =  test.getClass();
            try {
    
                Method  m;
                /*公有方法调用
                 */
                //有参数
                m =  allm.getMethod("youcan", String.class);
                m.invoke(test, "有参数的调用!");//对象和参数
                //无参数
                m =  allm.getMethod("wucan");
                m.invoke(test);
                /*
                 * 私有方法调用
                 */
                m = allm.getDeclaredMethod("siyou");
                m.setAccessible(true);
                m.invoke(test);
                /*获取私有属性
                 * 和私有属性的赋值
                 */
                Field filed = allm.getDeclaredField("name");//获取单个私有属性
                //设置访问私有属性权限
                filed.setAccessible(true);
                //调用和设置私有变量属性
                filed.set(test, "测试私有属性赋值");
                m = allm.getDeclaredMethod("shuxing");
                m.setAccessible(true);
                m.invoke(test);
    
                Field[] fid = allm.getDeclaredFields();//获取所有私有属性
                for (int i = 0; i < fid.length; i++) {
                    fid[i].setAccessible(true);//权限访问私有属性
                    fid[i].set(test, i + "测试20181008");
                }
                m = allm.getDeclaredMethod("allshuxingh");
                m.setAccessible(true);//权限访问私有方法
                m.invoke(test);
    
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }

    五、测试结果

    利用java反射调用类的属性和方法

    展开全文
  • //默认调用People无参构造器 People p1 = (People)oj1; System.err.println(p1.getName()); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e....
    
    
    public class People {
    	
    	private String name;
    	
    	public People(){
    		
    		this.name = "默认名字";
    		
    	}
    	
    	public People(String str) {
    		name = str;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    
            public void positive_negative() {   
    
    	}
    	
    }
    
    
    
    class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		
    		Object oj1;
    		
    		try {
    			
    			Class class1 = Class.forName("diaoYong.People");   //类的完整路径
    			oj1 = class1.newInstance();   //默认调用People的无参构造器
    			
    			People p1 = (People)oj1;
    			
    			System.err.println(p1.getName());
    			
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (InstantiationException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    
    }
    

     


     

    
    
    class BMW {
    	private String color = "black";
    	
    	public BMW(String name, double price, String color) {
    		super(name, price);
    		this.color = color;
    	}
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    	
    	private int hahaha() {
    		return 5;
    	}
    	
    	
    }
    
    
    import java.lang.reflect.*;
    
    class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		BMW car = new BMW("bmw320",300000.0,"white");
    		
    		
    		Class class1 = car.getClass();
    
    		
    		try {
    			Field field = class1.getDeclaredField("color");
    			field.setAccessible(true);
    			
    			System.out.println(field.get(car));
    				
    		} catch (NoSuchFieldException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalArgumentException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		
    		
    	}
    
    }
    

     


     

    
    
    class BMW extends Car{
    	private String color = "black";
    	
    	public BMW(String name, double price, String color) {
    		super(name, price);
    		this.color = color;
    	}
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    	
    	private int hahaha(int x) {
    		return x;
    	}
    	
    	
    }
    
    
    
    import java.lang.reflect.Method;
    
    class Test1 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		BMW b = new BMW("京A", 200.00, "yellow");
    		
    		
    		try {
    			Class class1 = b.getClass();
    			Method method1 = class1.getDeclaredMethod("hahaha",int.class);
    			method1.setAccessible(true);
    			
    			int a =(int)method1.invoke(b,5);
    			System.err.println(a);
    			
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} 
    		
    		
    	}
    
    }
    

     

    展开全文
  • package me.test; import java.lang.reflect.*; //导入反射需要包 public class ReflectTest {  public static void main(String[] ... /* 下面通过反射完成对一个对象中成员替换  * 并且执行执行私有方
     
    

    package me.test;
    import java.lang.reflect.*;  //导入反射需要的包
    public class ReflectTest {
     public static void main(String[] args)  throws  Exception
     { 
      
      /*  下面通过反射完成对一个对象中成员的替换
       *   并且执行执行私有方法 
       *   完成对 Poiont类的对象中所有的 String的对象的d换成x
       *   并且类中无修改方法   
       */
        Point pt=new Point(3,5);  //创建一个Point对象
        Field fx=pt.getClass().getField("x") ;  //获取x的映射类对象
        Field fy=pt.getClass().getDeclaredField("y");//因为y是私有的所以要调用这个方法
        Method m2=Point.class.getDeclaredMethod("showPrivate") ;//获得私有方法映射类 
       
        //利用反射调用共有输出
        m2.setAccessible(true)  ;// 修改showPrivate 权限 改变为可以调用
           m2.invoke(pt) ;//执行私有方法
        //利用成员反射输出x 和 私有的 y 
        System.out.println(fx.getInt(pt));//反射输出x 
        fy.setAccessible(true) ;//改变私有为可访问
        System.out.println(fy.getInt(pt));//输出私有y
           
        //替换成员后并且反射私有方法输出
        changeString(pt) ;//反射替换成员值
         System.out.println(pt);
       
       
     }
     public static void changeString(Object obj)  throws Exception//反射替换对所有String进行替换
     {
      Field[] f=obj.getClass().getFields()  ; //获得成员映射数组
      for(Field tem : f)  //迭代for循环
      {
       if(tem.getType()==String.class)  //内存中只有一份String字节码
       {
        String oldString=(String)tem.get(obj) ;  //返回内容
        String newString=oldString.replace('d', 'x');//将所有b替换为x 
        tem.setAccessible(true);
         tem.set(obj, newString) ;//替换成员值
       }
       
      }
      
     }

    }


    public class Point
    {
     public int x  ;
     private int y  ;
     public Point(int x, int y) {
      super();
      this.x = x;
      this.y = y;
     }
       public String  a="dsfdsfd"  ;  //只有 共有可以替换
       public String  b="fdsfdsfewewwwww"  ;
       public String  c="adddssss"  ;

     private void showPrivate()  //私有方法输出
     {
      System.out.println("x="+this.x+"\n"+"y="+this.y);
      System.out.println(this.a);
      System.out.println(this.b);
      System.out.println(this.c);
     }

     public String toString()
     {
      return this.a+"\n"+this.b+"\n"+this.c;
     }

    }

     

    展开全文
  • 有时候,你会想使用Android自带某个控件,但发现某些参数需要重新设置,但是并没有暴露出来修改入口。 这时反射就可以帮上你忙了~ 我们以RecyclerView为例,看看反射的使用方法

    有时候,你会想使用Android自带的某个控件,但发现某些参数需要重新设置,但是并没有暴露出来修改的入口。

    这时反射就可以帮上你的忙了~


    我们以RecyclerView为例,看看反射的使用方法。

    在RecyclerView.java中有这样一个方法smoothScrollBy(int dx,int dy)源码如下:


    /**
     * Animate a scroll by the given amount of pixels along either axis.
     *
     * @param dx Pixels to scroll horizontally
     * @param dy Pixels to scroll vertically
     */
    public void smoothScrollBy(int dx, int dy) {
        if (mLayout == null) {
            Log.e(TAG, "Cannot smooth scroll without a LayoutManager set. " +
                    "Call setLayoutManager with a non-null argument.");
            return;
        }
        if (mLayoutFrozen) {
            return;
        }
        if (!mLayout.canScrollHorizontally()) {
            dx = 0;
        }
        if (!mLayout.canScrollVertically()) {
            dy = 0;
        }
        if (dx != 0 || dy != 0) {
            mViewFlinger.smoothScrollBy(dx, dy);
        }
    }

    这里有一个私有的mViewFlinger成员对象,该对象是RecyclerView类中的一个私有内部类ViewFlinger的一个实例。

    private class ViewFlinger implements Runnable

    ViewFlinger有一个方法smoothScrollBy(int dx, int dy, int duration)

    public void smoothScrollBy(int dx, int dy, int duration) {
        smoothScrollBy(dx, dy, duration, sQuinticInterpolator);
    }

    在RecyclerView的smoothScrollBy(int dx,intdy)中,令mViewFlinger调用自己的smoothScrollBy(int dx, int dy, int duration)方法,duration的值自己设置。目的是可以通过控制duration的值,来控制滚动时间。


    下面就是继承RecyclerView重新定义一个方法smoothScrollBy(int dx,int dy, int duration)方法,在方法中利用反射获得RecyclerView的私有属性,并调用属性对象mViewFlinger方法smoothScrollBy(int dx, int dy, int duration)

    请注意代码中的注释,跟关键哦~

        public void smoothScrollBy(int dx, int dy, int duration) {
            try {
                Class<?> c = null;
                try {
                    c = Class.forName("android.support.v7.widget.RecyclerView");//获得Class对象
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                    return;
                }
    
                /**
                 * 对应代码
                 * if (mLayout == null) {
                 *      Log.e(TAG, "Cannot smooth scroll without a LayoutManager set. " +
                 *          "Call setLayoutManager with a non-null argument.");
                 *      return;
                 * }
                 */
                Field mLayoutField = c.getDeclaredField("mLayout");//根据属性名称,获得类的属性成员Field
                mLayoutField.setAccessible(true);//设置为可访问状态
                LayoutManager mLayout = null;
                try {
                    mLayout = (LayoutManager) mLayoutField.get(this);//获得该属性对应的对象
                    if(mLayout == null){
                        return;
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    return;
                }
    
                /**
                 * 对应代码
                 * if (mLayoutFrozen) {
                 *      return;
                 * }
                 */
                Field mLayoutFrozen = c.getDeclaredField("mLayoutFrozen");
                mLayoutFrozen.setAccessible(true);
                try {
                    if((Boolean)mLayoutFrozen.get(this)){
                        return;
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    return;
                }
    
                /**
                 * 对应代码
                 * if (!mLayout.canScrollHorizontally()) {
                 *      dx = 0;
                 * }
                 */
                if (!mLayout.canScrollHorizontally()) {
                    dx = 0;
                }
    
                /**
                 * 对应代码
                 * if (!mLayout.canScrollVertically()) {
                 *      dy = 0;
                 * }
                 */
                if (!mLayout.canScrollVertically()) {
                    dy = 0;
                }
    
                /**
                 * 对应代码
                 * if (dx != 0 || dy != 0) {
                 *      mViewFlinger.smoothScrollBy(dx, dy);
                 * }
                 * 此处调用mViewFlinger.smoothScrollBy(dx, dy, duration);这是我们的目的。
                 */
                Field mViewFlingerField = c.getDeclaredField("mViewFlinger");
                mViewFlingerField.setAccessible(true);
                try {
                    Class<?> ViewFlingerClass = null;
                    try {
                        //由于内部类是私有的,所以不能直接得到内部类名,
                        //通过mViewFlingerField.getType().getName()
                        //可以得到私有内部类的完整类名
                        ViewFlingerClass = Class.forName(mViewFlingerField.getType().getName());
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                        return;
                    }
    
                    //根据方法名,获得我们的目标方法对象。第一个参数是方法名,后面的是该方法的入参类型。
                    // 注意Integer.class与int.class的不同。
                    Method smoothScrollBy = ViewFlingerClass.getDeclaredMethod("smoothScrollBy",
                            int.class, int.class, int.class);
                    smoothScrollBy.setAccessible(true);//设置为可操作状态
                    if (dx != 0 || dy != 0) {
                        Log.d("MySmoothScrollBy", "dx="+dx + " dy="+dy);
                        try {
                            //唤醒(调用)方法,
                            // mViewFlingerField.get(this)指明是哪个对象调用smoothScrollBy。
                            // dx, dy, duration 是smoothScrollBy所需参数
                            smoothScrollBy.invoke(mViewFlingerField.get(this), dx, dy, duration);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                    return;
                }
            }catch (NoSuchFieldException e){;
                return;
            }
    
        }

    大功告成,睡觉!





    展开全文
  • 在Java中,调用类的方法有两种方式:静态方法直接调用,非静态通过类的对象调用在反射中可以根据需要指定要调用的方法,而不必在编程时确定,不仅限于public或者privatepublicclassMethodTest{ publicstaticvoidmain...
  • * 利用递归找一个类的指定方法,如果找不到,去父亲里面找直到最上层Object对象为止。 * * @param clazz 目标 * @param methodName 方法名 * @param classes 方法参数类型数组 * @return 方法对象 * @...
  • package me.test; import java.lang.reflect.*; //导入反射需要包 public class ReflectTest { .../* 下面通过反射完成对一个对象中成员替换 * 并且执行执行私有方法 * 完成对 Poiont...
  • package me.test; import java.lang.reflect.*; //导入反射需要包 public class ReflectTest { public static void main(String[] args) ... /* 下面通过反射完成对一个对象中成员替换 * 并且执行执行私...
  • 一.反射的概念 1.1什么是反射反射就是把Java类中的各种成分映射成一个个的Java对象。例如,一个类有:成员变量,方法,构造方法,包等等...Method类—可调用类的方法 Constructor类—可调用类的构造方法 ** ...
  • 话不多说,直接上代码 <?... class User { ...// 反射拿到 $class = new ReflectionClass('User'); // 获取对象实例 $obj = $class->newInstance(); // 获取方法对象 $method = $class-&g.
  • java利用反射机制(reflection),可以动态调用某个类的某个方法,在扩展系统功能或提供对外接口时经常用到。 举例实现 toUpperCased使用方法为:**“aaa”.toUpperCase();**返回值类型为String。 public ...
  • 在VS.Net中,有很多种方法动态调用对象的构造函数。一是通过Activator的CreateInstance()方法。这个方法我们在Remoting中也用过。它实际上是在本地或从远程创建对象类型,或获取对现有远程对象的引用。它的方法...
  • 在.NET中的反射可以实现从对象的外部来了解对象(或程序集)内部结构的功能,哪怕你不知道这个对象(或程序集)是个什么东西,另外.NET中的反射还可以运态创建出对象并执行它其中的方法反射是.NET中的重要机制,...
  • 使用newInstance()创建对象 要求有Class对象对应类的类有默认构造方法,实际是利用默认构造方法来创建该类的实例 2.使用Constructor对象创建对象 获取该类的Class对象 使用Class对象获取值定Constructor对象 再...
  • 利用反射动态调用类成员 使用反射来调用类的方法,需要使用Java.lang.reflect.Method中的invoke方法,Object??invoke(Object obj, Object[] args),第一个参数是指需要调用的那个方法的隐式参数,也即那个方法...
  • 根据反射机制,调用带参数构造函数创建对象时1.不管类的访问权限是否为public ,当前被调用的构造函数一定要是public 。2.在调用CreateInstance方法时,参数args中值一定要转化成构造函数参数对应类型。ICash...
  • 创建的对象:调用Class对象的newInstance()方法2.例子demo3. 反射创建对象和正常对象的底层理解 1. java 利用反射创建运行时的对象 1.1. 创建的对象:调用Class对象的newInstance()方法 要 求: 必须...
  • import java.lang.reflect.*; public class ReflectOperation { /* 获取类的实例化对象 */ public static Object getClassInstance(String class_name) throws Exception { Class<?...
  • 比如知道一个类的对象,我们知道方法的名称,但是只有在运行时候才知道调用哪个方法,这样只能用反射的方式调用了,拿List举例 List list = new ArrayList(); 但是我们只有在实际运行时候材质到时调用add...
  • 一个BeanUtil用来完成利用反射操作Student对象的成员变量赋值和调用其setter方法。 StudentTest是程序入口。 package reflect; public class Student { private String name; private String hobby; ...
  • Golang语言实现了反射反射机制就是在运行时动态的调用对象的方法和属性,官方自带的reflect包就是反射相关的,只要包含这个包就可以使用。 多插一句,Golang的gRPC也是通过反射实现的。 Golang的官方包 reflect ...
  • java 利用反射实例化类对象

    千次阅读 2014-10-04 10:06:22
    * 第一种方式:创建类类对象,调用类类对象的newInatance方法获取要实例化的类的对象,然后调用对象的setter方法设置属性。 * 第二种方式:使用类类对象的getConatructor方法构造Constructor类对象,然后用构造器...
  • 这篇文章是为之后要介绍Android的ICO框架做预备的,所以,如果想最近学习Android的ICO框架的同学,可以稍微看一下。...这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 不知道这样的一
  •  这篇文章是为之后要介绍Android的ICO框架做预备的,所以,如果想最近学习Android的ICO框架的同学,可以稍微看一下。...这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 不知道
  • 加载器获取Class对象 Class clazz= classLoader.loadClass("com.wxw.test.blockqueue.RefTest"); 步骤三: 使用Class对象获取想要指向目标私有方法 m是方法名,null指没有参数 Method method= clazz.get
  • java反射的原理,以及利用反射实现调用已知class文件的方法和属性 -1.什么是java反射? (1) 一个写好的java文件,需要编译为class文件才可以在JVM中运行。 (2)而反射是指 程序jvm在运行时利用反射可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,143
精华内容 457
关键字:

利用反射调用类对象的方法