精华内容
下载资源
问答
  • java反射在javaFX中的运用

    javaFX应用开发时 必然会涉及到part页面的读取 一个part相当于一个HTML的页面,相对于Swing SWT javaFX开发的CS端的程序不需要使用代码去写页面,而是可以通过工具SceneBuilder拖拽生成类似HTML代码的FXML,怎么样把这个FXML加载到你的客户端中呢?


            首先javaFX提供FXMLLoader对象

    protected Parent loadFXML() throws IOException {
    FXMLLoader loader = new FXMLLoader();
    loader.setClassLoader(getClass().getClassLoader());
    loader.setLocation(getClass().getResource(path));
    loader.setController(this);
    content = loader.load();
    return content;
    }

    这里的part就是要读取FXML的路径,也就是这个FXML文件所在包的路径

    这里的setController(this) 指的是 所有的页面FXML都会有一个Controller去控制他 这个controller是一个java类

    需要继承有loadFXML这个方法的类

    我们姑且给这个类起名叫partParent

           在这个partParent类中依赖注入一个BordePane

    再讲方法返回的content  Set给这个BorderPan就实现里页面的读取了

    然后

    在这里设置对应Controller的路径就可以了


    现在有些人可能会有疑问了 ,那这和java反射有什么关系呢?


    咱不着急 现在给你们说说


    既然所有的Controller都要继承partParent

    所以partParent类里肯定有一个path字段

    给他的无参构造器加一个

      this.path = this.getClass().getSimpleName() + ".fxml";


    这句话什么意思呢

    就是让你的Controller和你的FXML名字一样 程序就可以通过这种反射的方式知道里的FXML文件叫什么(FXML和Controller要在一个包下)

    这就只要Controller和FXML文件名相同 然后继承了partParent这个类 客户端启动的时候就可以自动读取加载了


    展开全文
  • ReflectTest.java package test; import java.beans.IntrospectionException; import java.beans.PropertyDescriptor; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.

    转载请注明出处:http://blog.csdn.net/droyon/article/details/8607756

    ReflectTest.java

    package test;
    
    import java.beans.IntrospectionException;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Array;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    /**
     * 
     * @author Administrator
     *反射主要有Class类、Field类,Constructor类,Method类、Array类
     */
    public class ReflectTest {
    	public static void main(String args[]){
    		Class clazz = null;
    		//获取class对象 
    		//Class clazz = TestJavaBean.class;
    		//Class clazz = new TestJavaBean().getClass();
    		try {
    			clazz = Class.forName("test.TestJavaBean");
    			//获取class包名
    			String packageName = clazz.getPackage().getName();
    			Log.d("包名:", packageName);
    			Log.d("类:",clazz.toString());
    			//获取类修饰符
    			int modify = clazz.getModifiers();
    			String mod = Modifier.toString(modify);
    			Log.d("类修饰符:",mod);
    			//获取类的全限定符
    			String className = clazz.getName();
    			Log.d("类全称:",className);
    			//获取父类
    			String superClazz = clazz.getSuperclass().getName();
    			Log.d("父类名称:",superClazz);
    			//获取实现的接口
    			Class[] interfaces = clazz.getInterfaces();
    			for(Class c :interfaces){
    				Log.d("实现的接口:",c.getName());
    			}
    			//成员变量
    			Field[] field = clazz.getDeclaredFields();
    			Log.d("分割线", "-------------------------");
    			for(Field f :field){
    				Log.d("成员变量:",f.getName()+"---"+f.getType().getName()+"---"+Modifier.toString(f.getModifiers()));
    			}
    			Log.d("分割线", "-------------------------");
    			//获取类的构造
    			Constructor[] constructors = clazz.getConstructors();
    			for(Constructor c :constructors){
    				Log.d("构造:",c.getName());
    				Class[] parasList = c.getParameterTypes();
    				for(Class paras :parasList){
    					Log.d("参数列表:",paras.getName());
    				}
    			}
    			
    			//获取所有的方法
    			Method[] m = clazz.getDeclaredMethods();
    			for(Method method :m){
    				Log.d("成员方法:",method.getName()+"---修饰符"+Modifier.toString(method.getModifiers())+"---返回类型"+method.getReturnType());
    				Class[] parasType = method.getParameterTypes();
    				for(Class paras:parasType){
    					Log.d("方法参数:",paras.getName());
    				}
    			}
    			
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		
    		//数组
    		int[] arr = new int[5];
    		Log.d("数组:",arr.getClass().getName()+"---"+arr.getClass().getCanonicalName()+"全名称:"+arr.getClass().getComponentType().getName());
    		
    		
    		//创建数组对象
    		Object obj = Array.newInstance(String.class, 3);
    		for(int i=0;i<3;i++){
    			Array.set(obj, i, "第"+(i+1)+"个元素");
    		}
    		for(int i=0;i<3;i++){
    			Log.d("创建的数组对象数据:",Array.get(obj, i)+"");
    		}
    		
    		
    		//创建对象
    //		TestJavaBean test = (TestJavaBean) createClassFactory.createClassObject("test.TestJavaBean");
    		try {
    			TestJavaBean test = (TestJavaBean) clazz.newInstance();
    		} catch (InstantiationException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		try {
    			Constructor c = clazz.getConstructor();//得到有参和无参构造方法
    			try {
    				TestJavaBean test = (TestJavaBean) c.newInstance();
    				test.setName("helloword");
    				Log.d("使用构造实例化对象:",test.getName());
    			} catch (IllegalArgumentException 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();
    			} catch (InvocationTargetException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		} catch (SecurityException e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		} catch (NoSuchMethodException e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
    		
    		//执行反射构造方法,如果类是标准的javaBean,那么可以使用PropertyDescriptor来获取方法名
    		//也可以直接使用方法名来获取方法,如果要获取私有(private)的方法,那么需要先调用Method.setAccessible(true)
    		//执行方法调用Method.invoke类执行方法。
    		//成员属性的得到 get和set
    		try {
    			Method method = clazz.getDeclaredMethod("getName");
    			try {
    				TestJavaBean  test = (TestJavaBean) clazz.newInstance();
    				test.setName("hellowork");
    				Object returnValue = method.invoke(test, null);
    				Log.d("反射执行方法:","返回值为:"+returnValue);
    				
    				Field f_name;
    				try {
    					f_name = clazz.getDeclaredField("name");
    					String name = (String) f_name.get(test);
    					Log.d("反射执行的成员属性",name);
    				} catch (NoSuchFieldException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				
    				
    				
    				
    				
    				//PropertyDescriptor
    				try{
    					Object new_w_r_object = clazz.newInstance();
    					PropertyDescriptor pd = new PropertyDescriptor("name", clazz);
    					Method m = pd.getWriteMethod();
    					m.invoke(new_w_r_object, "new helloword");
    					
    					Method m_read = pd.getReadMethod();
    					String read_name = (String) m_read.invoke(new_w_r_object, null);
    					Log.d("PropertyDescriptor read name :",read_name);
    				} catch (IntrospectionException 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();
    			} catch (InvocationTargetException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (InstantiationException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (NoSuchMethodException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	static class Log{
    		static void d(String tag ,String message){
    			System.out.println(tag+"-"+message);
    		}
    	}
    	
    	static class createClassFactory{
    		static Object createClassObject(String clazz){
    			Object obj = null;
    			try {
    				obj = Class.forName(clazz).newInstance();
    			} catch (InstantiationException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (IllegalAccessException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (ClassNotFoundException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			return obj;
    		}
    	}
    }


    TestJavaBean.java

    package test;
    /**
     * JavaBean
     * 有一个无参构造方法
     * 有属性,并且有get和set方法
     */
    public class TestJavaBean {
    	private int id;
    	public String name = null;
    	protected long index;
    	boolean isTestOk;
    	int[] array;
    	
    	public int[] getArray() {
    		return array;
    	}
    
    	public void setArray(int[] array) {
    		this.array = array;
    	}
    
    	public TestJavaBean(){}
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public long getIndex() {
    		return index;
    	}
    
    	public void setIndex(long index) {
    		this.index = index;
    	}
    
    	public boolean isTestOk() {
    		return isTestOk;
    	}
    
    	public void setTestOk(boolean isTestOk) {
    		this.isTestOk = isTestOk;
    	};
    	
    	
    }


    展开全文
  • java反射运用举例-junit测试私有方法

    千次阅读 2015-10-28 16:29:57
    记得以前刚接触junit那会,对于公有方法的测试运用的很是流畅,并且私有方法也是在这些公有方法中调用,都会测试覆盖到。 由于是新建的类,新建的方法,造数据一步一步的覆盖跑下去,确实只要有耐心,都可以搞定。...
           记得以前刚接触junit那会,对于公有方法的测试运用的很是流畅,并且私有方法也是在这些公有方法中调用,都会测试覆盖到。

    由于是新建的类,新建的方法,造数据一步一步的覆盖跑下去,确实只要有耐心,都可以搞定。

    但是随着项目的逐渐深入,由于人员成本,时间成本等等问题,测试类的维护不知道从哪一个版本,

    哪一位开发人员修改了业务逻辑开始,已经问题百出,一线飘红了,但是项目一直跑着也没出现什么问题[运气不错],

    而且时间成本等问题一直存在,但是在这时你只是修改了私有方法的一部分逻辑,但是测试类你这次又必须得维护,

    所以有两点必须解决:

    1.把原有的测试case按照现有的逻辑把【主体】调通。

    2.测试自己修改过的私有方法业务逻辑。


    关于第一点没啥捷径,根据主逻辑调通。

    关于第二点可以修改私有方法的修饰符,但是这种方式需要改动代码,所以不太靠谱,建议不要使用!

    此处介绍通过反射来测试私有方法,方便实用!也能深刻体验一下反射的好处!


    // 待测试的私有方法类
    public class MethodClass
    {
        private int add(int a, int b)
        {
            return a + b;
        }
    }

    // junit测试类
    public class MethodClassTest extends TestCase
    {
        public void testAdd()
        {
            MethodClass mc = new MethodClass();

            // 得到class对象
            Class<MethodClass> clazz = MethodClass.class;


            // 得到方法
            try
            {
                Method method = clazz.getDeclaredMethod("add", new Class[] {int.class, int.class });// 这里也可以用:Integer.TYPE

                method.setAccessible(true);// 抑制访问修饰符,使得私有方法变为可以访问的

                Object result = method.invoke(mc, new Object[] { 2, 3 });

                Assert.assertEquals(5, result);
            }
            catch (Exception e)
            {
                e.printStackTrace();

                Assert.fail();
            }
        }
    }



    展开全文
  • Java反射运用

    2017-08-29 17:27:08
    Java反射获取对象的运用

    用于反射的User类:

    public class User {
    	public User() {
    	}
    	
    	public User(String userName){
    		this.userName = userName;
    	}
    
    	private String userName;
    	
    	private String password;
    	
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    
    	public String getUserName(){
    		return userName;
    	}
    	
    	public void getUser(String userName){
    		System.out.println(userName+"获取到User了。");
    	}
    	
    }

    反射运用:

    public class UserReflect {
    
    	public static void main(String[] args) {
    		try {
    			/* ***** 获得Class对象 ***** */
    			//获取方式一:使用Class类的forName静态方法
    			//Class<?> clazz = Class.forName("com.tx.reflex.User");
    			
    			//获取方式二:直接获取某一个对象的class
    			Class<?> clazz = User.class;
    			
    			//获取方式二:调用某个对象的getClass()方法
    			//User userObj = new User();
    			//Class<?> clazz = userObj.getClass();
    			
    			/* ***** 创建对象 ***** */
    			//创建对象方式一:Class对象的newInstance()方法创建Class对象对应类的实例
    			User user = (User) clazz.newInstance();
    			
    			//创建对象方式二:Class对象获取指定的Constructor对象,
    			//再调用Constructor对象的newInstance()方法来创建实例[可以用指定的构造器构造类的实例]
    			//getConstructor(String.class) --> 带一个String参数的构造器
    			Constructor<?> constructor = clazz.getConstructor(String.class);
    			User userConstructor = (User) constructor.newInstance("张三");
    			
    			/* ***** 获取对象方法 ***** */
    			//返回类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法
    			Method[] declaredMethods  = clazz.getDeclaredMethods();
    			
    			//返回某个类的所有公用(public)方法,包括其继承类的公用方法
    			Method[] methods = clazz.getMethods();
    			
    			//返回一个特定的方法,其中第一个参数为方法名称,后面的参数为方法的参数对应Class的对象
    			Method method = clazz.getMethod("getUser", String.class);
    			
    			//调用method对应的方法 => getUser("张三")
    			Object result = method.invoke(user,"张三");
    			
    			/* ***** 获取对象内部类 ***** */
    			//返回类中定义的公共、私有、保护的内部类
    			Class<?>[] DeclaredClazzS = clazz.getDeclaredClasses();
    			
    			//返回类定义的公共的内部类,以及从父类、父接口那里继承来的内部类
    			Class<?>[] clazzS = clazz.getClasses();
    			
    			/* ***** 获取对象成员变量 ***** */
    			//访问所有公有的成员变量
    			Field[] fields = clazz.getFields();
    			
    			//所有已声明的成员变量。但不能得到其父类的成员变量
    			Field[] declaredFields = clazz.getDeclaredFields();
    			
    			Field field = clazz.getField("");
    			
    			Field declaredField = clazz.getDeclaredField("");
    			
    			//判断是否为某个对象的实例
    			boolean b = clazz.isInstance(new User());
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		} 
    	}
    }



    展开全文
  • JAVA反射

    2015-09-25 14:59:42
    JAVA反射运用public static <T> boolean copyPropertiesNotNull(T source,T target,String ...params){ Field[] fields = source.getClass().getDeclaredFields();//获取源所有字段 Method m; Object valu
  • JAVA反射机制运用教程

    2017-11-20 10:15:05
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 Java...
  • java反射机制是在运行状态中,对任意一个类,都能知道这个类的所有属性和方法;对于任意一个对象,都能调用它的任意方法和属性,这种动态获取信息以及动态调用方法的功能称为java语言的反射机制 实例运用: 在将一...
  • hibernate继承关系映射和java反射机制的运用
  • java 中通过反射创建对象
  • java反射机制和运用

    2015-12-26 12:02:12
    开发中最基本的反射,你知道吗?
  • Java 反射

    千次阅读 2016-01-04 07:39:46
    Java 反射标签: Java基础动态语言 动态语言,是指程序在运行时可以改变其结构:新的函数可以被引进,已有的函数可以被删除等在结构上的变化。比如众所周知的ECMAScript(JavaScript)便是一个动态语言。除此之外如...
  • java反射

    千次阅读 2016-04-23 17:28:54
    java反射学习的总结,通过图示,Class的介绍、获得与运用来体现反射的内容概念。后续有代码实现与测试结果图。还有关于反射的拓展。
  • Java反射运用反射生成jdk动态代理

    千次阅读 热门讨论 2015-07-28 21:42:23
     在Javajava.lang.reflect包下提供一个Proxy类和一个InvocationHandler接口,通过使用这个类和接口可以生成jdk动态代理类或动态代理对象。  Proxy是所有动态代理类的父类,它提供了两个静态方法来创建动态代理类...
  • 主要介绍了Java反射机制的运用,对一些常用的类作了一些说明,需要的朋友可以参考下
  • Java反射机制

    2019-02-27 23:01:38
    一,Java反射机制的意义 Java反射机制是就Java语言...此外,在ORM中间件的实现中,运用Java反射机制来读取任意一个JavaBean的所有属性,或者给这些属性赋值。 ------------------------------------------------...
  • Java反射

    2017-02-20 13:53:19
    好久都没有回顾java反射了,在实际编程中很少会直接使用反射去实现某些功能,但是我们常用的开发框架里面都有反射技术,可以说反射技术是无处不在!! 一,先看一下反射的概念:  主要是指程序可以访问,检测和修改它...
  • JAVA反射的简单总结 通过学习本文档后能够掌握到的知识点 1什么是反射 2反射的作用是什么 3如何使用反射 4 反射的应用场景是什么 子曰:“学而不思则罔,思而不学则殆。” 1. 反射是什么? 反射是什么...
  • 主要介绍了Java 反射和反射的应用场景的相关资料,帮助大家更好的理解和学习Java反射的相关知识,感兴趣的朋友可以了解下
  • java伪泛型的特性, 通过反射往Integer类型的list添加string public class Test { public static void main(String[] args) throws Exception { ArrayList<Integer> list = new ArrayList<Integer>()...
  • JAVA反射机制 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的...
  • 运用java反射机制还原类的属性,方法,修饰符运用java反射机制将类的所有所属性,方法还原。
  • 我们可以运用java反射机制获取注解的类然后进行类解析机制获取到这个类的所有属性。 首先我们要明白java5.0后有几种注解方式元注解:  元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation...
  • 上一篇讲了 通过反射创建对象,这一篇说说 通过反射调用一个类的方法 如果看过了上一篇文章,那么这一篇就很好理解了 如同上一篇文章一样,主要的方法基本上都是通过 Class 这个类(是个入口) 1.得到方法 对象...
  • Java反射运用

    千次阅读 2013-10-17 23:31:33
    什么是反射呢?  我们都知道,java中,一个类有多个组成部分,例如:成员变量,方法,构造方法等。...框架中很多都运用到了反射。      那么我们该如何使用反射呢?又该用其中的那些方法去

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,502
精华内容 10,600
关键字:

java的反射运用

java 订阅