反射

反射：

Class类是一切的反射根源。
Class类表示什么？很多很多的类

package com.vince;
public class Dog {
private String name;
private int age;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Dog() {
}
public Dog(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return “Dog{” +
“name=’” + name + ‘’’ +
“, age=” + age +
“, color=’” + color + ‘’’ +
‘}’;
}
}

得到Class类的对象有三种方式：
1、Object类中的getClass()方法
2、类.class
3、通过class类的forName方法

使用Class类进行对象的实例化操作

调用类中的方法
调用类中的方法，传入实例化对象，以及具体的参数内容
public Object invoke(Object obj,Object…args)
直接调用属性
取得属性
public Object get(Object obj)
//设置属性，等同于使用“=”完成操作
public void set(Object obj,Object value)
//让属性对外部可见
public void setAccessible(boolean flag)

示例：
package com.vince;
import org.junit.Test;
import java.lang.reflect.;
public class ReflectionDemo {
@Test
public void test5(){
Dog dog=new Dog(“wangwang”,4,“白色”);
Class dogClass = Dog.class;
//获取类的包名
Package aPackage = dogClass.getPackage();
//System.out.println(aPackage.getName());
//获取公共的方法，包括继承的共有方法
Method[] methods = dogClass.getMethods();
for (int i=0;i<methods.length;i++){
System.out.println(methods[i]);
if (methods[i].getName().equals(“toString”)){
try {
String s = (String) methods[i].invoke(dog);
System.out.println(s);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
System.out.println("------------");
//访问私有方法,获取本类中定义的所有的方法（不包括父类）
Method[] declaredMethods = dogClass.getDeclaredMethods();
for (int i=0;i<declaredMethods.length;i++){
System.out.println(declaredMethods[i]);
if (declaredMethods[i].getName().equals(“set”)){
//设置私有方法可以被访问（去除访问修饰符的检查）
declaredMethods[i].setAccessible(true);
try {
Object invoke = declaredMethods[i].invoke(dog);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
/
获取所有属性
私有的属性不能传过去
共有的属性能传
/
@Test
public void test4(){
//获取非私有的属性
Class dogClass = Dog.class;
Field[] fields = dogClass.getFields();
//System.out.println(fields.length);
//获取所有属性，包括私有属性
Field[] declaredFields =dogClass.getDeclaredFields();
//System.out.println(declaredFields.length);
for (int i=0;i<declaredFields.length;i++){
int modifiers=declaredFields[i].getModifiers();
System.out.println(Modifier.toString(modifiers)+" “+declaredFields[i].getType()+” "+declaredFields[i].getName());
}
}
@Test
//获取所有的构造方法
public void test3(){
Class dogClass= Dog.class;
Constructor<?> [] constructors=dogClass.getConstructors();
for (int i=0;i<constructors.length;i++){
System.out.println(constructors[i].getName());
System.out.println(constructors[i].getParameterCount());
}
try {
//获取一个指定的构造方法
Constructor constructor=dogClass.getConstructor(String.class,int.class,String.class);
//调用带参数的构造器来实例化对象
Dog dog=constructor.newInstance(“小白”,5,“白色”);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/
通过反射来实例化对象
*/
@Test
public void test2() {
Class dogClass=Dog.class;
try {
Dog dog=dogClass.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
@Test
public void test1(){
//通过对象的getclass（）方法
Dog dog=new Dog(“wangwang”,4,“白色”);
Class aclass=dog.getClass();
//通过类
Class dogclass=Dog.class;
//通过class.forName方法
try {
Class aClass = Class.forName(“com.vince.Dog”);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}