java反射机制概念以及应用
-java反射机制是java的核心，许多高级的应用都以反射机制为基础得以实现。
java.lang.Class;// 通过Class类可以获取一个类类型完整的结构定义！
public final class Class
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement；
–返回类对象的完整包路径名：
Object类定义了getClass方法：
public final Class> getClass()；// 返回类型为Class类，此类是java反射机制的源头，
// 反射：可以通过对象反射求出类的名称！
Returns the runtime class of this Object. The returned Class object is the object that is locked by static synchronized methods of the represented class.
// Class类中定义了getName方法：
public String getName()
String.class.getName()
returns “java.lang.String”
byte.class.getName()
returns “byte”
(new Object[3]).getClass().getName()
returns “[Ljava.lang.Object;”
(new int[3][4][5][6][7][8][9]).getClass().getName()
returns “[[[[[[[I”
// 正常方式： 引入需要的‘包类'名称–>通过‘new'运算符–>取得实例化对象；
// 反射方式： 实例化对象–>getClass()方法–>得到完整的'包类'名称；
—
package com.mldn;
class T
{
}
public class GetClass
{
public static void main(String[] args)
{
T t = new T(); // 实例化T类
System.out.println(t.getClass().getName()); // 获取t对象的class完整路径名
}
}
/*
ubuntu@xu-desktop:~$ java com.mldn.GetClass
com.mldn.T
// 返回的是完整的包路径名！
*/
———–实例化基于泛型的Class对象：
// 方法1：使用forName方法：
public static Class> forName(String className)
throws ClassNotFoundException；// 返回指定类或接口的Class对象，
Returns the Class object associated with the class or interface with the given string name. Invoking this method is equivalent to: // 默认使用以下设置：
Class.forName(className, true, currentLoader)// 这是重载的方法
where currentLoader denotes the defining class loader of the current class.
For example, the following code fragment returns the runtime Class descriptor for the class named java.lang.Thread:
Class t = Class.forName(“java.lang.Thread”) // 获取Thread类的Class对象
A call to forName(“X”) causes the class named X to be initialized. // 此方法的调用将实例化X字符串表示的类；
// 方法2：类对象.getClass();
// 方法3:类.class;
—
package com.mldn;
class T
{
}
public class GetClass
{
public static void main(String[] args)
{
Class> c1 = null; // 指定泛型
Class> c2 = null; // 指定泛型
Class> c3 = null; // 指定泛型
T t = new T(); // 实例化T类
try
{
c1 = Class.forName(“com.mldn.T”); // 通过类的完整路径名获取Class对象,将实例化T
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
c2 = t.getClass(); // 通过类对象获取Class对象
c3 = T.class; // 通过类获取Class对象
System.out.println(“Class.forName(…).getName()：类名称：\t ” + c1.getName()); // 获取t对象的class完整路径名
System.out.println(“t.getClass().getName()：类名称：\t ” + c2.getName()); // 获取t对象的class完整路径名
System.out.println(“T.class.getName()：类名称：\t ” + c3.getName()); // 获取t对象的class完整路径名
}
}
/*
ubuntu@xu-desktop:~$ java com.mldn.GetClass
Class.forName(…).getName()：类名称： com.mldn.T
t.getClass().getName()：类名称： com.mldn.T
t.class.getName()：类名称： com.mldn.T
*/
——–用Class类的方法为类实例化一个对象：使用泛型的无参构造方法；
public T newInstance() // 非静态接口，由Class的对象调用，将默认调用泛型的无参构造方法，没有无参构造的泛型无法用此方法实例化！
throws InstantiationException,
IllegalAccessException；// 该方法获取一个泛型的实例；和new效果一样；
package com.mldn;
public class InstanceDemo
{
public static void main(String[] args)
{
Class> c = null; // 声明Class对象，？表示泛型：即可以接收任意类类型
try
{
c = Class.forName(“com.mldn.Person”); // 实例化Class对象，
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
Person per = null; // 声明一个Person对象
try
{
per = (Person)c.newInstance(); // 得到c对象操作的泛型的一个实例，c的类型：Class> ，包含Class
}
catch (InstantiationException e)
{}
catch (IllegalAccessException e)
{}
per.setName(“张三”);
per.setAge(32);
System.out.println(per);
}
}
class Person
{
private String name = null;
private int age = 0;
public Person()
{}
public Person(String name, int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public String toString()
{
return “姓名：” + this.name + ” 年龄：” + this.age;
}
}
/*
ubuntu@xu-desktop:~$ java com.mldn.InstanceDemo
姓名：张三 年龄：32
// newInstance()方法和new的效果一样；
*/
———用Class反射获取泛型构造方法，以有参构造方法实例化泛型；
//1. 首先找到有参构造：
public Constructor>[] getConstructors()
throws SecurityException；// 获取泛型所有的构造方法数组；
public Constructor
throws NoSuchMethodException,
SecurityException；// 获取确定参数的构造方法；
//2. 通过构造函数java.lang.reflect.Constructor的newInstance 方法获取泛型的实例，调用匹配参数的有参构造；
public T newInstance(Object… initargs)
throws InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException；// 接收可变参数，返回泛型实例：
—实例：
package com.mldn;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class InstanceDemo
{
public static void main(String[] args)
{
Class> c = null; // 声明Class对象，？表示泛型：即可以接收任意类类型
try
{
c = Class.forName(“com.mldn.Person”); // 实例化Class对象，
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
Person per = null; // 声明一个Person对象
Constructor>[] cons = null; // 声明泛型构造器数组
try
{
cons = c.getConstructors(); // 反射获取c关联的泛型类的所有构造方法；
}
catch (SecurityException e)
{}
try
{
per = (Person)cons[1].newInstance(“张三”, 30); // 得到c对象操作的泛型的一个实例，c的类型：Class> ，包含Class
}
catch (IllegalArgumentException e)
{}
catch (InstantiationException e)
{}
catch (IllegalAccessException e)
{}
catch (InvocationTargetException e)
{}
System.out.println(per);
}
}
class Person
{
private String name = null;
private int age = 0;
public Person()
{}
public Person(String name, int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public String toString()
{
return “姓名：” + this.name + ” 年龄：” + this.age;
}
}
/*
ubuntu@xu-desktop:~$ java com.mldn.InstanceDemo
姓名：张三 年龄：32
// newInstance()方法和new的效果一样；
*/
声明: 除非转自他站（如有侵权，请联系处理）外，本文采用 BY-NC-SA 协议进行授权 | 智乐兔
转载请注明：转自《java反射机制概念以及应用》
本文地址：https://www.zhiletu.com/archives-136.html
关注公众号：
微信赞赏
支付宝赞赏
鲁公网安备 37011302000311号
