JAVA基础-反射机制

什么是JAVA的反射机制

Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其

modifiers（诸如public, static等）、superclass（例如Object）、实现之

interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行

时改变fields内容或唤起methods。

Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。

换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

 

JAVA反射机制提供了什么功能

Java反射机制提供如下功能：

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判段任意一个类所具有的成员变量和方法

在运行时调用任一个对象的方法

 

从接口 java.lang.reflect

​​

获取类的Class对象

Class类的实例表示正在运行的Java应用程序中的类和接口。获取类的Class对象有多种方式：

调用getClass：

Boolean var1 = true;

Class<?> classType2 = var1.getClass();System.out.println(classType2);

输出：class java.lang.Boolean

 

 

运用.class语法

Class<?> classType4 = Boolean.class;

System.out.println(classType4);

输出：class java.lang.Boolean

 

运用static methodClass.forName()

Class<?> classType5= Class.forName("java.lang.Boolean");

System.out.println(classType5);

输出：class java.lang.Boolean

 

运用primitive wrapper classes

 

Class<?> classType3 = Boolean.TYPE;

System.out.println(classType3);

输出：boolean

TYPE语法这里返回的是原生类型，和Boolean.class返回的不同

 

 

public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();
Person p2 = new Person();
Class c2 = p2.getClass();
System.out.println(p == p2);// false
System.out.println(c == c2);// true
// 方式2
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);
// 方式3
// ClassNotFoundException
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
}

 

获取类的Fields

可以通过反射机制得到某个类的某个属性，然后改变对应于这个类的某个实例的该属性值。

JAVA的Class<T>类提供了几个方法获取类的属性。

 

 

// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");
// 获取单个的成员变量
// 获取address并对其赋值
Field addressField = c.getField("address");
// public void set(Object obj,Object value)
// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
System.out.println(obj);

// 获取name并对其赋值
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);

// 获取age并对其赋值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 27);
System.out.println(obj);

 

 

 

可见getFields和getDeclaredFields区别：

getFields返回的是申明为public的属性，包括父类中定义，

getDeclaredFields返回的是指定类定义的所有定义的属性，不包括父类的。

 

 

获取类的Method

通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法

Class<T>类提供了几个方法获取类的方法。

 

getMethod

public Method getMethod(String name,
                        Class<?>... parameterTypes)
                 throws NoSuchMethodException,
                        SecurityException

class

null

 

public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

// 获取所有的方法
// Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
// Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
// for (Method method : methods) {
// System.out.println(method);
// }
  
//创建新类的实例
Constructor con = c.getConstructor();
Object obj = con.newInstance();

/*
 * Person p = new Person(); p.show();
 */

// 获取单个方法并使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
Method m1 = c.getMethod("show");
// obj.m1(); // 错误
// public Object invoke(Object obj,Object... args)
// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
m1.invoke(obj); // 调用obj对象的m1方法

System.out.println("----------");
// public void method(String s)
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");

// public String getString(String s, int i)
Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// String s = (String)m3.invoke(obj, "hello",100);
// System.out.println(s);
System.out.println("----------");

// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}

 

获取类的Constructor

通过反射机制得到某个类的构造器，然后调用该构造器创建该类的一个实例

Class<T>类提供了几个方法获取类的构造器。

 

 

//使用getConstructors获取构造器
Constructor<?>[] constructors = classType.getConstructors();for(Constructor<?> m : constructors)
{
System.out.println(m);
}

 

//使用getDeclaredConstructors获取构造器
constructors = classType.getDeclaredConstructors();
for(Constructor<?> m : constructors)
{
System.out.println(m);
}

 

通过反射去获取该构造方法并使用

 

 

public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

// 获取带参构造方法对象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,
String.class);

// 通过带参构造方法对象创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 27, "北京");

System.out.println(obj);
}
}

 

 

通过反射获取私有构造方法并使用

 

public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

// 获取私有构造方法对象
// NoSuchMethodException：每个这个方法异常
// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
Constructor con = c.getDeclaredConstructor(String.class);

// 用该私有构造方法创建对象
// IllegalAccessException:非法的访问异常。
// 暴力访问
con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
Object obj = con.newInstance("风清扬");

System.out.println(obj);
}
}

 

新建类的实例

调用类的Class对象的newInstance方法

该方法会调用对象的默认构造器，如果没有默认构造器，会调用失败.

 

Class<?> classType = ExtendType.class;
Object inst = classType.newInstance();
System.out.println(inst);

 

输出：

Type:Default Constructor

ExtendType:Default Constructor

com.quincy.ExtendType@d80be3

 

调用默认Constructor对象的newInstance方法

 

Class<?> classType = ExtendType.class;
Constructor<?> constructor1 =
classType.getConstructor();
Object inst = constructor1.newInstance();
System.out.println(inst);

 

输出：

Type:Default Constructor

ExtendType:Default Constructor

com.quincy.ExtendType@1006d75

 

调用带参数Constructor对象的newInstance方法

 

Constructor<?> constructor2 =
classType.getDeclaredConstructor(int.class,
String.class);
Object inst = constructor2.newInstance(1, "123");
System.out.println(inst);

 

输出：

Type:Default Constructor

ExtendType:Constructor with parameters

com.quincy.ExtendType@15e83f9