定义

在运行期间可以获取对象的类型，类型的方法，类型的属性，类型的构造方法等，让对象可以认识到自身的结构。

方法

【1】获取对象的类型

（1）方法一

Object.getclass()

public class Reflect {
private String name;
}
class Test{
public static void main(String[] args) {
//方法一：Object.getclass()
Class<? extends Reflect> reflectclass = new Reflect().getClass();
System.out.println(reflectclass);
//class Reflect
//方法二：class.forName("类名")
try {
Class<?> reflect = Class.forName("Reflect");
System.out.println(reflect);
//class Reflect
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//方法三：类名.class
System.out.println(Reflect.class);
//class Reflect
}
}

（2）方法二

class.forName(“类名”)；

（3）方法三

类名.class;

【2】类对象的功能

[1]用反射的方式创建对象

我们先比较一下正常创建对象和反射创建对象的不同：

（1）正常创建对象

new 类名();

（2）反射创建对象

创建一个新实例对象：类对象.newInstance();
当然利用反射来创建对象是有限制的：

• 构造方法不能私有
• newInstance要求对象有无参构造

try {
Reflect reflect = Reflect.class.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}

[2]获取方法信息

public class Reflect {
private String name;
private int age;
@Override
public String toString() {
return "Reflect{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

我们来对Reflact这个类做反射，获取它的所有方法信息

class Test{
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
//获取某个公共方法，包括继承的
Method method = Class.forName("Reflect").getMethod("getAge");
System.out.println(method.toString());
//获取所有公共方法包括继承的
Method[] methods = new Reflect().getClass().getMethods();
for (Method method1 : methods) {
System.out.println(method1.toString());
}
//获取本类中所有的方法
Method[] declaredMethods = Reflect.class.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.toString());
}
//找本类的方法，不包括继承的
Method setAge = new Reflect().getClass().getDeclaredMethod("setAge", int.class);
System.out.println(setAge.toString());
//
public int Reflect.getAge()
//
public java.lang.String Reflect.toString()
//
public void Reflect.setAge(int)
//
public int Reflect.getAge()
//
public final void java.lang.Object.wait() throws java.lang.InterruptedException
//
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//
public boolean java.lang.Object.equals(java.lang.Object)
//
public native int java.lang.Object.hashCode()
//
public final native java.lang.Class java.lang.Object.getClass()
//
public final native void java.lang.Object.notify()
//
public final native void java.lang.Object.notifyAll()
//
public java.lang.String Reflect.toString()
//
public void Reflect.setAge(int)
//
public int Reflect.getAge()
//
public void Reflect.setAge(int)
}
}

[3]获取属性信息

//获取属性信息
//获取所有属性信息，包括继承的
Field[] fields = new Reflect().getClass().getFields();
for (Field field : fields) {
System.out.println(field.toString());
}
//获取某个属性信息(必须是public 的属性才可以拿到)
Field name = new Reflect().getClass().getField("age");
System.out.println(name.toString());
//获取本类某个属性
Field declaredField = Class.forName("Reflect").getDeclaredField("age");
System.out.println(declaredField.toString());
//获取本类的所有属性
Field[] reflects = Class.forName("Reflect").getDeclaredFields();
for (Field reflect : reflects) {
System.out.println(reflect.toString());
}
//
public int Reflect.age
//
public int Reflect.age
//
public int Reflect.age
//
private java.lang.String Reflect.name
//
public int Reflect.age

这里要强调一下，用getField(属性名")这个方法的时候，属性不能是private
否则会抛出异常：java.lang.NoSuchFieldException: age

[4]获取构造方法

//获取所有的构造方法
Constructor<?>[] constructors = new Reflect().getClass().getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor.toString());
}
//获取int类型参数的构造方法
Constructor<?> constructor = Class.forName("Reflect").getConstructor(int.class);
System.out.println(constructor.toString());
//获取无参构造
Constructor<? extends Reflect> constructor1 = new Reflect().getClass().getConstructor();
System.out.println(constructor1.toString());
//获取本类所有的构造方法
Constructor<?>[] reflects1 = Class.forName("Reflect").getDeclaredConstructors();
for (Constructor<?> constructor2 : reflects1) {
System.out.println(constructor2.toString());
}

[5]反射调用方法

（1）正常调用方法

对象.方法名（参数）

（2）反射调用方法

== 方法.invole(对象，参数)==

方法.setAccessible(true)
//设置这个方法可以被访问，可以突破访问修饰符的限制

缺点：性能低，调用复杂

Method getName = Reflect.class.getDeclaredMethod("gn");
getName.invoke(new Reflect());

最后

以上就是听话钻石为你收集整理的反射定义方法的全部内容，希望文章能够帮你解决反射定义方法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。