java---反射

反射概述
Java反射机制:是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。
由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

获取Class类的对象

package 反射.获取Class类的对象;

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共
    public Student(){
    }

    private Student(String name){
        this.name = name;
    }

    Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public  Student(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法：一个私有，四个公共
    private void function(){
        System.out.println("function");
    }

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

    public void method2(String s){
        System.out.println("method"+s);
    }

    public String method3(String s,int i){
        return s+","+i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

package 反射.获取Class类的对象;
/*
    获取Class类的对象
        我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
        这里我们提供三种方式获取Class类型的对象

        1.使用类的class属性来获取该类对应的Class对象。
            举例:Student.class将会返回Student类对应的Class对象
        2.调用对象的getClass()方法，返回该对象所属类对应的Class对象
            该方法是Object类中的方法，所有的Java对象都可以调用该方法
        3.使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，
            该字符串参数的值是某个类的全路径，也就是完整包名的路径
 */

import 集合基础.ArrayList构造方法与添加方法;

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象。
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2 = Student.class;
        System.out.println(c1==c2);
        System.out.println("---------");

        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s=new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);
        System.out.println("---------");

        //使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("反射.获取Class类的对象.Student");
        System.out.println(c1==c4);



    }
}

反射获取构造方法并使用

package 反射.获取构造方法并使用;
/*
反射获取构造方法并使用
    Class类中用于获取构造方法的方法
        Constructor<?>[]getConstructors():返回所有公共构造方法对象的数组
        Constructor<?>[]getDeclaredConstructors():返回所有构造方法对象的数组

        Constructor<T>getConstructor(Class<?>…parameterTypes):返回单个公共构造方法对象
        Constructor<T>aetDeclaredConstructor(Cass<?>…parameter Types):返回单个构造方法对象

    Constructor类中用于创建对象的方法
        T newInstance(Object...initargs):根据指定的构造方法创建对象
 */

import 方法引用.引用类方法.Converter;

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

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //Constructor<?>[]getConstructors():返回所有公共构造方法对象的数组
//        Constructor<?>[] cons = c.getConstructors();

        //Constructor<?>getDeclaredConstructors():返回所有构造方法对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for (Constructor con:cons) {
            System.out.println(con);
        }
        System.out.println("--------");


        //onstructor<T>getConstructor(Class<?>…parameterTypes):返回单个公共构造方法对象
        //Constructor<T>aetDeclaredConstructor(Cass<?>…parameter Types):返回单个构造方法对象
        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象

        Constructor<?> con = c.getConstructor();

        //Constructor提供了一个类的单个构造函数的信息访问权限
        //T newInstance(Object...initargs):根据指定的构造方法创建对象
        Object obj = con.newInstance();
        System.out.println(obj);


    }
}

练习

package 反射.获取构造方法并使用;
/*
    反射获取构造方法并使用练习
        练习1:通过反射实现如下操作
            Students=new Student("萧炎",19,"乌坦城");
            System.out.println(s);
            基本数据类型也可以通过.class得到对应的Class类型
 */

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

public class 练习 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //public  Student(String name, int age, String address)
        //Constructor<T>getConstructor(Class<?>…parameterTypes)
        Constructor<?> con = c.getConstructor(String.class,int.class,String.class);
        //基本数据类型也可以通过.class得到对应的Class类型

        //T newInstance(Object...initargs):根据指定的构造方法创建对象
        Object obj = con.newInstance("萧炎", 19, "乌坦城");
        System.out.println(obj);

    }
}

练习2

package 反射.获取构造方法并使用;
/*
    练习2:通过反射实现如下操作
        Students=new Student("萧炎”);
        System.out.println(s);
        public void setAccessible(boolean flag):值为true，取消访问检查
 */

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

public class 练习2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //private Student(String name)
        //Constructor<T>aetDeclaredConstructor(Cass<?>…parameter Types)
        Constructor<?> con = c.getDeclaredConstructor(String.class);

        //暴力反射
        //public void setAccessible(boolean flag):值为true，取消访问检查
        con.setAccessible(true);

        Object obj = con.newInstance("萧炎");
        System.out.println(obj);

    }
}

获取成员方法并使用

package 反射.获取成员方法并使用;
/*
    Class类中用于获取成员方法的方法
        Method[] getMethods():返回所有公共成员方法对象的数组，包括继承的
        Method[] getDeclaredMethods():返回所有成员方法对象的数组，不包括继承的

        Method getMethod(String name,Class<?>… parameterTypes):返回单个公共成员方法对象
        Method getDeclaredMethod(String name,Class<?>… parameterTypes):返回单个成员方法对象

    Method类中用于调用成员方法的方法
        Object invoke(Object obj,Object…args):调用obj对象的成员方法，参数是args,返回值是Object类型
 */

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

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //Method[] getMethods():返回所有公共成员方法对象的数组，包括继承的
        //Method[] getDeclaredMethods():返回所有成员方法对象的数组，不包括继承的
//        Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------");

        //Method getMethod(String name,Class<?>… parameterTypes):返回单个公共成员方法对象
        //Method getDeclaredMethod(String name,Class<?>… parameterTypes):返回单个成员方法对象
        //public void method1()
        Method m = c.getMethod("method1");

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //obj.m();

        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj,Object…args):调用obj对象的成员方法，参数是args,返回值是Object类型

        m.invoke(obj);


    }
}

练习

package 反射.获取成员方法并使用;
/*
    反射获取成员方法并使用练习
        练习:通过反射实现如下操作
        Student s=new Student();
        s.method1();
        s.method2("萧炎");
        String ss=s.method3("萧炎”，19);
        System.out.println(ss);
        s.function();
 */

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

public class 练习 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //Student s=new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //s.method1();
        Method m1 = c.getMethod("method1");
        m1.invoke(obj);


        //s.method2("萧炎");
        Method m2 = c.getMethod("method2", String.class);
        m2.invoke(obj);


        //String ss=s.method3("萧炎”，19);
        Method m3 = c.getMethod("method3", String.class, int.class);
        Object o = m3.invoke(obj, "萧炎", 19);
        System.out.println(o);

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


    }
}

反射获取成员变量并使用

package 反射.获取成员变量并使用;
/*
    反射获取成员变量并使用
        Class类中用于获取成员变量的方法
            Field getFields():返回所有公共成员变量对象的数组
            Field getDeclaredFields():返回所有成员变量对象的数组

            Field getField(String name):返回单个公共成员变量对象
            Field getDeclaredField(String name):返回单个成员变量对象

        Field类中用于给成员变量赋值的方法
            void set(Object obj,Object value):给obj对象的成员变量赋值为value
 */

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

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //Field getFields():返回所有公共成员变量对象的数组
        //Field getDeclaredFields():返回所有成员变量对象的数组
//        Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");

        //Field getField(String name):返回单个公共成员变量对象
        //Field getDeclaredField(String name):返回单个成员变量对象
        Field addressField = c.getField("address");

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //obj.addressField = "乌坦城";

        //Field 提供有关类或接口的单个字段的信息和动态访问
        //void set(Object obj,Object value):给obj对象的成员变量赋值为value
        addressField.set(obj,"乌坦城");//给obj的成员变量addressField赋值

        System.out.println(obj);



    }
}

练习

package 反射.获取成员变量并使用;
/*
    反射获取成员变量并使用练习
        练习:通过反射实现如下操作
        Student s=new Student();
        s.name="萧炎”;
        s.age=19;
        s.address=“乌坦城”;
        System.out.println(s);
 */

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

public class 练习 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("反射.获取Class类的对象.Student");

        //Student s=new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);

        //s.name="萧炎”;
        Field nameField = c.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(obj,"萧炎");
        System.out.println(obj);

        //s.age=19;
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,19);
        System.out.println(obj);

        //s.address=“乌坦城”;
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true);
        addressField.set(obj,"乌坦城");
        System.out.println(obj);
    }

}

综合练习

package 反射.综合练习;

public class Student {
    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

package 反射.综合练习;

public class Teacher {
    public void teach(){
        System.out.println("用爱成就学员");
    }
}

/*className = 反射.获取Class类的对象.Student
methodName = study
*/

package 反射.综合练习;
/*
    练习：我想有一个ArrayList<Integer>集合，现在我想在这个集合中添加一个字符串数据，如何实现？

 */

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Properties;

public class ReflectTest {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
        //创建集合
        ArrayList<Integer> array = new ArrayList<Integer>();

/*        array.add(10);//可以
        array.add(20);//可以
        array.add("hello");//不可以
*/
        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);

        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");

        System.out.println(array);

        /*
            class.txt
            className = xxx
            methodName = xxx
         */

        //加载数据
        Properties prop=new Properties();
        FileReader fr=new FileReader("idea_text\\class.txt");
        prop.load(fr);
        fr.close();

        /*
            className = 反射.获取Class类的对象.Student
            methodName = study
         */

        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射来使用
        Class<?> cc = Class.forName(className);

        Constructor<?> con = cc.getConstructor();
        Object obj = con.newInstance();

        Method mm = cc.getMethod(methodName);
        mm.invoke(obj);


    }
}