反射的具体应用反射出方法和类等等

最新推荐文章于 2020-07-06 16:44:15 发布

阿送

最新推荐文章于 2020-07-06 16:44:15 发布

阅读量555

点赞数

分类专栏： JAVA反射机制文章标签：类 arraylist junit jdk 反射

本文链接：https://blog.csdn.net/u010139093/article/details/38445825

版权

JAVA反射机制专栏收录该内容

8 篇文章 0 订阅

订阅专栏

首先建立一个类，里面有各种各样的方法的字段，然后用反射来调用，调用的时候用junit来测试

package com.fts.reflect;

import java.io.InputStream;
import java.util.List;

public class Person {
	public String name="first test";
	private int passwd=123;
	private static int age=100;
	
	
	
	public Person(){
		System.out.println("person");
	}
	public Person(String name){
		System.out.println("person name:"+name);
	}
	public Person(String name,int passwd){
		System.out.println("person name:"+name+"  passwd:"+passwd);
	}
    private Person(List list){
    	System.out.println("list");
    }
    public void test(){
    	System.out.println("test");
    }
    public void test(String name,int passwd){
    	System.out.println("test:"+name+"   :"+passwd);
    }
    public Class[] test(String name,int[] passwd){
    	return new Class[]{String.class};
    }
    private void test(InputStream in){
    	System.out.println(in);
    }
    public static void test(int num){
    	System.out.println(num);
    }
    public static void main(String[] args){
    	System.out.println("main method");
    }
}

反射，加载类的三种方法

package com.fts.reflect;

public class Demo1 {

	/**
	 * 反射，加载类，获得类的字节码
	 * @param args
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		// TODO Auto-generated method stub
        //方法一
		Class clazz=Class.forName("com.fts.reflect.Person");
	    
		//方法二
		Class clazz1=new Person().getClass();
		
		//方法三
		Class clazz2=Person.class;
	
	    System.out.println(clazz==clazz1);
	    System.out.println(clazz1==clazz2);
	}

}

反射出构造函数

package com.fts.reflect;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

/*
 * 解剖构造函数，创建类的对象
 */
public class Demo2 {
	//反射构造函数 public Person(){}
	@Test
	public void test1() throws Exception{
		//将类加载进内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖构造函数
		Constructor c=clazz.getConstructor(null);
		//创建一个对象
		Person p=(Person) c.newInstance(null);
		System.out.println(p.name);
		
	}
	//反射构造函数 public Person(string name){}
	@Test
	public void test2() throws Exception{
		//将类加载进内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖构造函数
		Constructor c=clazz.getConstructor(String.class);
		//创建一个对象
		Person p=(Person) c.newInstance("my name");
		System.out.println(p.name);
		
	}
	//反射构造函数 public Person(string name,int passwd){}
	@Test
	public void test3() throws Exception{
		//将类加载进内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖构造函数
		Constructor c=clazz.getConstructor(String.class,int.class);
		//创建一个对象
		Person p=(Person) c.newInstance("my name",888888);
		System.out.println(p.name);
		
	}
	//反射构造函数 private Person(List list){}
	@Test
	public void test4() throws Exception{
		//将类加载进内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		//解剖构造函数
		Constructor c=clazz.getDeclaredConstructor(List.class);
		c.setAccessible(true);//暴力强暴打开
		//创建一个对象
		Person p=(Person) c.newInstance(new ArrayList());
		System.out.println(p.name);
		
	}
	//创建对象的另一种形式
	@Test
	public void test5() throws Exception{
		//将类加载进内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
		Person p=(Person) clazz.newInstance();
		System.out.println(p);
		
		
	}

}

反射类的其它方法

package com.fts.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;

import org.junit.Test;

//反射类的方法
public class Demo3 {
	//反射类的方法 public void test(){}
	@Test
	public void test1() throws Exception{
		Person p=new Person();
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getMethod("test",null);
		method.invoke(p, null);
	
	}
	//反射类的方法 public void test(String name,int passwd){}
	@Test
	public void test2() throws Exception{
		Person p=new Person();
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getMethod("test",String.class,int.class);
		method.invoke(p, "fengtansong",100);
	
	}
	//反射类的方法 public Class[] test(String name,int[] passwd)
	@Test
	public void test3() throws Exception{
		Person p=new Person();
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getMethod("test",String.class,int[].class);
		Class cs[]=(Class[]) method.invoke(p, "fengtansong",new int[]{1,2,3});
	    System.out.println(cs[0]);
	}
	//反射类的方法 private void test(InputStream in)
	@Test
	public void test4() throws Exception{
		Person p=new Person();
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getDeclaredMethod("test",InputStream.class);
		method.setAccessible(true);
		method.invoke(p,new FileInputStream("c:\\1.txt"));
		
	}
	//反射类的方法 public static void test(int num)
	@Test
	public void test5() throws Exception{
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getMethod("test",int.class);
		//静态方法调用不需要对象
		method.invoke(null,1000);
		
	}
	//反射类的方法 public static void main(String[] args)
	@Test
	public void test6() throws Exception{
		//将类加载在内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    //加载类的方法
		Method method=clazz.getMethod("main",String[].class);
		//静态方法调用不需要对象
		//method.invoke(null,new Object[]{new String[]{"1"}});
		method.invoke(null,(Object)new String[]{"1"});
		
	}

}

反射出字段

package com.fts.reflect;

import java.lang.reflect.Field;

import org.junit.Test;

//反射字段
public class Demo4 {
	//反射字段public String name="first test";
	@Test
	public void test1() throws Exception{
		Person p=new Person();
		//将类加载到内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	    Field f=clazz.getField("name");	
	    //String name=(String) f.get(p);
	    //System.out.println(name);
	   // Class type=f.getType();
	   // System.out.println(type);
	    //获取字段的值
	    Object value=f.get(p);
	    //获取字段的类型
	    Class type=f.getType();
	    if(type.equals(String.class)){
	    	String svalue=(String) value;
	    	System.out.println(svalue);
	    }
	    
	    //设置字段的值
	    f.set(p,"xxxxxxxxxx");
	    System.out.println(p.name);
	}
	//反射字段private int passwd=123;
	@Test
	public void test2() throws Exception{
		Person p=new Person();
		//将类加载到内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	   //获得对象
		Field f=clazz.getDeclaredField("passwd");
		f.setAccessible(true);
		System.out.println(f.get(p));
	}
	//反射字段private static int age=100;
	@Test
	public void test3() throws Exception{
		Person p=new Person();
		//将类加载到内存中
		Class clazz=Class.forName("com.fts.reflect.Person");
	   //获得对象
		Field f=clazz.getDeclaredField("age");
		f.setAccessible(true);
		System.out.println(f.get(p));
	}

}

通过以上的例子简单理解了反射的应用

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：
Class类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method类：代表类的方法。
Constructor 类：代表类的构造方法。
Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

一、通过Class类获取成员变量、成员方法、接口、超类、构造方法等

在java.lang.Object 类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。Class类是Reflection API 中的核心类，它有以下方法
getName()：获得类的完整名字。
getFields()：获得类的public类型的属性。
getDeclaredFields()：获得类的所有属性。
getMethods()：获得类的public类型的方法。
getDeclaredMethods()：获得类的所有方法。
getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
getConstructors()：获得类的public类型的构造方法。
getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。