【Java】---反射

反射

什么是反射:在运行状态中,对于任意一个类,我们都能知道这个类的所有属性和方法.

反射中重要的四个类

类名	用途
Class类	代表类的实体,在java应用程序中表示类和接口
Filed类	代表类的成员变量
Method类	代表类的方法
Constructor类	代表类的构造方法

class类中的相关方法

获得类的相关方法

方法	用途
getClassLoader()	获得类的加载器
getDeclaredClasses()	返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)	根据类名返回类的对象
newInstance()	创建类的实例
getName()	获得类的完整路径名字

获得类中属性的相关方法

方法	用途
getField(String name)	获得某个公有的属性对象
getFields()	获得所有公有的属性对象
getDeclaredField(String name)	获得某个属性对象
getDeclaredFields()	获得所有属性对象

获得类中构造器的相关方法

方法	用途
getConstructor(Class…<?> parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	获得该类的所有公有构造方法
getDeclaredConstructor(Class…<?> parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

获得类中方法的相关方法

方法	用途
getMethod(String name, Class…<?> parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class…<?> parameterTypes)	获得该类某个私有方法
getDeclaredMethods()	获得该类所有方法

测试类

class Student{
    //私有属性name
    private String name = "bit";
    //公有属性age
    public int age = 18;
    //不带参数的构造方法
    public Student(){
        System.out.println("Student()");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }
    private void function(String str) {
        System.out.println(str);
    }

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

获取class对象的方式

1.通过Class.forname(“类的全路径名”);

try {
           Class<?> c1 = Class.forName("Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

2.类名.class的方法;

 Class<?> c2 = Student.class;

3.使用类对象的getClass()方法

Student  student = new Student();
Class<?> c3 = student.getClass();

一个类对应一个class对象

public static void main(String[] args) {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        Class<?> c2 = Student.class;

        Student  student = new Student();
        Class<?> c3 = student.getClass();

        System.out.println(c1 == c2);
        System.out.println(c2 == c3);
        System.out.println(c1 == c3);
    }

运行结果：

上述代码使用三种不同的方法创建的class对象都相等，说明一个类对应一个class对象。

利用反射实例化对象

利用class对象的newInstance()方法来实例化对象。(不安全：能在类外访问到私有的构造方法)

public static void main(String[] args) {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("Student");
            Student student = (Student) c1.newInstance();
            System.out.println(student);
            student.sleep();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

反射获得私有的构造方法

public static void reflectPrivateConstructor() {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("Student");

            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class);

            constructor.setAccessible(true);//设置权限
            //在类外调用了私有的构造方法
           Student student = (Student) constructor.newInstance("张三",18);
            System.out.println(student);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

运行结果：

反射获得私有属性

public static void reflectPrivateField() {
        Class<?> c1 = null;
        try {
            //1.通过Student类创建class对象
            c1 = Class.forName("Student");
            //2.通过class对象获取字段名为name的私有字段
            Field field = c1.getDeclaredField("name");
            //获取权限
            field.setAccessible(true);
            //通过class对象实例化student对象
            Student student = (Student) c1.newInstance();
            field.set(student,"张三");//修改student对象的filed字段修改为张三
            System.out.println(student);
            //获取私有属性的值
            String str = (String) field.get(student);
            System.out.println(str);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }  catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

运行结果：

反射获得私有方法

public static void reflectPrivateMethod() {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("Student");
            Method method = c1.getDeclaredMethod("function", String.class);
            method.setAccessible(true);
            Student student =(Student) c1.newInstance();
            method.invoke(student,"我是Sudent对象的的私有方法。");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

运行结果：

面试题：Java中创建对象的方式有几种

1.NEW

2.clone

3.class对象的newInstance()方法

反射的优点和缺点

优点:

1.对于任意一个类,都能知道这个类的所有属性个方法;对于任意一个对象,都能调用它的任意一个方法.

2.增加程序的灵活性和扩展性,降低耦合性,提高自适应能力.

3.反射已经运行再了很多的流行框架中:Struts/Hibernate/Spring等等

缺点:

1.使用反射会有效率降低.

2.反射技术绕过来源代码的技术,因而会带来维护问题.反射代码比相应的直接代码更复杂.