java--反射机制

Java反射机制主要提供了以下功能：在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。反射最大的应用就是框架

下面代码:
1:反射的三种实例化方法
2：通过反射调用有参构造方法（Constructor类）
3：通过反射调用类的成员方法（Method类）
4：通过反射调用类的成员参数，对参数进行解封装操作（Filed类）；

package main.java.learn;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class apple{
    public void print(){
        System.out.println("apple");
    }
}
class orange{
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {

        return name;
    }

    public orange(String name){
        this.name=name;
    }
    public void print(){
        System.out.println(this.name);
    }
}
public class abstractClass extends Thread{
    public void test1(){
        //三种源头类实例化方法

        //通过getclass()方法
        apple a=new apple();
        Class<?> cls=a.getClass();
        System.out.println(cls.getName());
        //通过 lei.class获得
        cls=String.class;
        System.out.println(cls.getName());
        //通过类的全路径名称获得,这种是最常用的反射操作使用方法
        try {
            cls=Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(cls.getSimpleName());
    }
    public void test2(){
        //利用反射实例化对象，主要用于解决使用new产生的耦合现象（例如工厂中的new耦合现象）
        try {
            Class<?> cls=Class.forName("main.java.learn.apple");
            try {
                Object obj=cls.newInstance();//newInstance()返回的为Object类型的对象，需要进行向下转型为对应的类
                //newInstance()方法调用的是类的无参构造方法，即要求提供无参构造方法，否则会抛出异常
                apple app=(apple)obj;//进行向下转型
                app.print();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //利用反射调用构造方法，避免类中没有无参构造方法
        //通过实例化Constructor类获得相应的含参构造方法
        try {
            Class cls=Class.forName("main.java.learn.orange");
            try {
                Constructor con=cls.getConstructor(String.class);
                try {
                    Object obj=con.newInstance("orange");
                    orange org=(orange)obj;
                    org.print();
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //利用反射调用对象方法，通过method类的成员方法进行调用
        try {
            Class cls = Class.forName("main.java.learn.orange");
            try {
                Constructor con = cls.getConstructor(String.class);
                try {
                    Object obj = con.newInstance("orange");
                    String o="orange";
                    Method setOrg=cls.getMethod("setName",String.class);
                    Method getOrg=cls.getMethod("getName");
                    System.out.println(getOrg.invoke(obj));
                    setOrg.invoke(obj,"Orange");
                    //这里的invoke方法是method类对象的成员方法，主要是为了实现对于method调用反射类方法的实现，第一个参数是Object对象，余下参数和调用的方法的参数相同
                    orange org=(orange)obj;
                    System.out.println(org.getName());
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //利用反射获得对象成员，通过Filed类的成员方法进行调用
        try {
            Class<?> cls=Class.forName("main.java.learn.orange");
            try {
                Constructor con=cls.getConstructor(String.class);
                try {
                    Object obj=con.newInstance("new orange");
                    try {
                        Field name=cls.getDeclaredField("name");//获得成员
                        name.setAccessible(true);//解封装，除去成员属性为private时所造成的外部成员无法直接访问的行为
                        name.set(obj,"old orange");//相当于正常调用set方法
                        System.out.println(name.get(obj));
                    } catch (NoSuchFieldException e) {
                        e.printStackTrace();
                    }
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args){
        new abstractClass().test2();
    }
}