java反射机制基础示例_讲解反射原理的基础示例-CSDN博客

本文链接：https://blog.csdn.net/qq133258852/article/details/44926545

程序示例代码

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;


/**
 * 
 * @ClassName: Demo
 * @author dylan_wang
 * @date 2015年4月2日 下午8:44:54
 * 
 */
@SuppressWarnings("rawtypes")
public class Demo {

    /**
     * 其实在java中有三种类类加载器。 1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
     * 2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类
     * 3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
     */

    /**
     * 如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，以完成代理的具体操作。
     */
    public static void main(String[] args) {
        // demo1();// 通过完整路径获取实例并利用无参构造函数构造实例
        // demo2();//通过构造函数构造实例
        // demo3();//返回一个类实现的接口
        // demo4();//取得其他类中的父类
        // demo5();//获取全部构造函数
        // demo6();//获取全部属性
        // demo7();//调用实例中的方法
        // demo8();//调用getter&setter
        // demo9();//通过反射操作属性
        // demo10();//通过反射取得并修改数组的信息
        // demo11();//通过反射修改数组大小
        // demo12();//类加载器
        // demo13();//接口代理操作
        // demo14();//通过反射使用工厂模式
    }

    public static void demo1() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        User per = null;
        try {
            per = (User) clas.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        per.setName("Rollen");
        per.setAge(20);
        System.out.println(per);
    }

    public static void demo2() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        User per1 = null;
        User per2 = null;
        User per3 = null;
        User per4 = null;
        // 取得全部的构造函数
        Constructor<?> cons[] = clas.getConstructors();
        try {
            per1 = (User) cons[0].newInstance("dylan", 25, "男");
            per2 = (User) cons[1].newInstance("Rollen", 25);
            per3 = (User) cons[2].newInstance("Rollen");
            per4 = (User) cons[3].newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }

    public static void demo3() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        Class<?>[] intes = clas.getInterfaces();
        for (Class<?> c : intes) {
            System.out.println("实现接口类：" + c.getSimpleName());
        }
    }

    public static void demo4() {
        Class<?> clas =getInstantiation("wang.dylan.demo.reflect.User");
        Class<?> parent = clas.getSuperclass();
        System.out.println(parent.getSimpleName());
    }

    public static void demo5() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");

        Constructor[] cons = clas.getConstructors();
        for (Constructor c : cons) {
            String str = "构造函数：" + Modifier.toString(c.getModifiers()) + " "
                    + getInstantiation(c.getName()).getSimpleName() + "(";
            Class<?>[] p = c.getParameterTypes();
            for (int i = 0; i < p.length; i++) {
                str += p[i].getSimpleName() + " arg" + i;
                if (i != p.length - 1) {
                    str += ",";
                }
            }
            str += "){}";
            System.out.println(str);
        }
    }

    public static void demo6() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        System.out.println("===============本类属性========================");
        Field[] fields = clas.getDeclaredFields();
        for (Field f : fields) {
            // 获取修饰符
            String str = Modifier.toString(f.getModifiers()) + " ";
            // 获取类型
            str += f.getType().getSimpleName() + " ";
            // 获取属性名
            str += f.getName();
            System.out.println(str);
        }
        System.out
                .println("===============实现的接口或者父类的属性========================");
        fields = clas.getFields();
        for (Field f : fields) {
            // 获取修饰符
            String str = Modifier.toString(f.getModifiers()) + " ";
            // 获取类型
            str += f.getType().getSimpleName() + " ";
            // 获取属性名
            str += f.getName();
            System.out.println(str);
        }
    }

    public static void demo7() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");

        try {
            Method method1 = clas.getMethod("method1");
            method1.invoke(clas.newInstance());
            Method method2 = clas.getMethod("method2", String.class,
                    Integer.class);
            method2.invoke(clas.newInstance(), "dylan", 25);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void demo8() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        Object obj = null;
        try {
            obj = clas.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        setter(obj, "Name", "dylan", String.class);
        getter(obj, "Name");
    }

    public static void demo9() {
        Class<?> clas = getInstantiation("wang.dylan.demo.reflect.User");
        try {
            Object obj = clas.newInstance();
            Field field = clas.getDeclaredField("name");
            field.setAccessible(true);
            field.set(obj, "dylan");
            System.out.println(field.get(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void demo10() {
        int[] temp = { 1, 2, 3, 4, 5 };
        Class<?> demo = temp.getClass().getComponentType();
        System.out.println("数组类型： " + demo.getName());
        System.out.println("数组长度  " + Array.getLength(temp));
        System.out.println("数组的第一个元素: " + Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之后数组第一个元素为： " + Array.get(temp, 0));
    }

    public static void demo11() {
        int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        int[] newTemp = (int[]) arrayInc(temp, 15);
        print(newTemp);
        System.out.println("=====================");
        String[] atr = { "a", "b", "c" };
        String[] str1 = (String[]) arrayInc(atr, 8);
        print(str1);
    }

    public static void demo12() {
        User u = new User();
        System.out.println("类加载器  "
                + u.getClass().getClassLoader().getClass().getName());
    }

    public static void demo13() {
        MyInvocationHandler mih = new MyInvocationHandler();
        Interface user = (Interface) mih.bind(new User());
        user.seaySchool();
    }

    public static void demo14() {
        for (int i = 0; i < 3; i++) {
            Interface inte = InterfaceFactory.getInstance("User", 0);
            inte.seaySchool();
        }

    }

    /**
     * 通过类名全称获得实例
     * 
     * @param str
     * @return
     */
    public static Class<?> getInstantiation(String str) {
        try {
            return Class.forName(str);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 通过实例获得类名全称
     * 
     * @param obj
     * @return
     */
    public static String getCompleteName(Object obj) {
        return obj.getClass().getName();
    }

    /**
     * 修改数组大小
     * */
    public static Object arrayInc(Object obj, int len) {
        Class<?> arr = obj.getClass().getComponentType();
        Object newArr = Array.newInstance(arr, len);
        int co = Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, co);
        return newArr;
    }

    /**
     * 打印
     * */
    public static void print(Object obj) {
        Class<?> c = obj.getClass();
        if (!c.isArray()) {
            return;
        }
        System.out.println("数组长度为： " + Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i) + " ");
        }
    }

    public static void getter(Object obj, String att) {
        try {
            Method method = obj.getClass().getMethod("get" + att);
            System.out.println(method.invoke(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void setter(Object obj, String att, Object value,
            Class<?> type) {
        try {
            Method method = obj.getClass().getMethod("set" + att, type);
            method.invoke(obj, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

接口类


public interface Interface {

    String shcool="school";

    void seaySchool();
}

抽象父类


public abstract class Parent {

    public String seriar="par";

    public void goHome(){
        System.out.println("goHome");
    }
}

实现类


public class Student implements Interface{

    public Student(){}



    @Override
    public void seaySchool() {
        System.out.println("student");

    }

}

实现类


public class User extends Parent implements Interface{

    public String name;
    public Integer age;
    public String sex;

    public User(){

    }
    public User(String name){
        this.name=name;
    }
    public User(String name,Integer age){
        this.name=name;
        this.age=age;
    }
    public User(String name,Integer age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    public void method1(){
        System.out.println("method1");
    }

    public void method2(String str,Integer i){
        System.out.println(str);
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
    @Override
    public void seaySchool() {
        System.out.println("user");
    }


}

代理类


import java.lang.reflect.*;
/**
 * InvocationHandler接口的子类，以完成代理的具体操作
 * @ClassName: MyInvocationHandler 
 * @author dylan_wang 
 * @date 2015年4月4日 上午11:50:28 
 *
 */
public class MyInvocationHandler implements InvocationHandler {

    private Object obj = null;

    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }

}

工厂类


import java.io.*;
import java.util.Properties;

public class InterfaceFactory {

    public static Interface getInstance(String str, Integer type) {
        Interface inte = null;
        if (type == 0) {
            if (str.equals("User")) {
                inte = new User();
            }
            if (str.equals("Student")) {
                inte = new Student();
            }
        }
        if (type == 1) {
            try {
                inte = (Interface) Class.forName(str).newInstance();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (type == 2) {
            try {
                String className = getPro().getProperty(str);
                inte = (Interface) Class.forName(className).newInstance();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return inte;
    }

    public static Properties getPro() throws FileNotFoundException, IOException {
        Properties pro = new Properties();
        File f = new File("interface.properties");
        if (f.exists()) {
            pro.load(new FileInputStream(f));
        } else {
            pro.setProperty("User", "wang.dylan.demo.reflect.User");
            pro.setProperty("Student", "wang.dylan.demo.reflect.Student");
            pro.store(new FileOutputStream(f), "INTERFACE CLASS");
        }
        return pro;
    }
}