浅谈JAVA中 类加载机制与反射
反射机制的概念
- 反射是Java中一个非常强大的工具,能够方便我们创建更加灵活的代码,这些代码可以在运行时进行装在
- 类中有什么信息,利用反射机制就能获得,不过必须知道类的全名
- 但是反射对系统的开销是比较大的。
反射机制的作用
- 静态编译:在编译时就确定类型,绑定对象。
- 动态编译:运行时确定类型,绑定对象。这点上极大限度的发挥了Java的灵活性,体现了多态的概念,用于降低类之间的耦合。
反射机制的优缺点
优点:可以实现动态创建对象和编译。
缺点:对性能有影响,它是一种解释性的操作,这类操做总是慢于直接执行相同的操作。代码示例
通过一个对象获得一个完整的包名和类名
public class Client2 {
public static void main(String[] args) {
Demo demo = new Demo();
// 根据对象获取完整的包名和类名
System.out.println(demo.getClass().getName());
}
}
class Demo2 {
}
实例化Class类对象
public class Client3 {
public static void main(String[] args) throws ClassNotFoundException {
// Class类是所有对象的元数据的类对象
Class<?> demo1 = null;
Class<?> demo2 = null;
Class<?> demo3 = null;
demo1 = Class.forName("com.ntqingniao.reflect.Demo3");
demo2 = new Demo3().getClass();
demo3 = Demo3.class;
System.out.println(demo1.getName());
System.out.println(demo2.getName());
System.out.println(demo3.getName());
}
}
class Demo3 {
}
通过Class实例化其他类的对象
package com.ntqingniao.reflect;
public class Client4 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> demo = null;
// 通过类全名创建Class对象(类型的工厂)
demo = Class.forName("com.ntqingniao.reflect.Person");
// 调用工厂的newInstance()方法创建对象
Person per = (Person)demo.newInstance();
per.setName("Tom");
System.out.println(per);
}
}
class Person {
private String name;
private int age;
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;
}
@Override
public String toString() {
return "Person [" + (name != null ? "name=" + name + ", " : "") + "age=" + age + "]";
}
}
注:在编写使用Class实例化其他类对象的时候,一定要定义一个无参的构造器。
通过Class调用类中的构造器
// 获取该类的所有构造器对象
Constructor<?> cons[] = demo.getConstructors();
// 通过构造器对象的newInstance(Object.. params)可变参数方法构建对象
Person per1 = (Person)cons[0].newInstance();
Person per2 = (Person)cons[1].newInstance("Tom", 20);
System.out.println(per1);
System.out.println(per2);
返回一个类实现的接口和继承的父类
// 获取类的所有接口和直接父类方法
Class<?> inters[] = demo.getInterfaces();
Class<?> supers = demo.getSuperclass();
获取一个类实现的接口和继承的父类
// 获取类的所有接口和直接父类方法
Class<?> inters[] = demo.getInterfaces();
Class<?> supers = demo.getSuperclass();
获取类的全部属性
// 获取类的全部属性
Field[] fields = demo.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
// 获取权限修饰符
int mo = fields[i].getModifiers();
String priv = Modifier.toString(mo);
// 数据类型
Class<?> type = fields[i].getType();
// 属性变量名
String name = fields[i].getName();
System.out.println(priv + " " + type.getName() + " " + name ) ;
}
调用类的方法
Method method = demo.getMethod("getName");
method.invoke(demo.newInstance());
Person p = new Person();
Method method2 = demo.getMethod("getName", String.class);
method2.invoke(p, "Reflect");
p.getName("Reflect");
调用Getter和Setter
public class Client5 {
public static void main(String[] args) throws Exception {
Human tom = new Human();
setter(tom, "Name", "Tom", String.class);
getter(tom, "Name");
System.out.println(tom);
}
public static void setter(Object obj, String attr, Object value, Class<?> type) throws Exception {
Method method = obj.getClass().getMethod("set" + attr, type);
method.invoke(obj, value);
}
public static void getter(Object obj, String attr) throws Exception {
Method method = obj.getClass().getMethod("get" + attr);
System.out.println(method.invoke(obj));
}
}
class Human {
private String name;
private int age;
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;
}
@Override
public String toString() {
return "Human [" + (name != null ? "name=" + name + ", " : "") + "age=" + age + "]";
}
}