java 反射机制

什么是反射？

反射就是把Java类中的各种成分映射成相应的Java类。例如：一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个类。表示Java类的Class类显然要提供一系列方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应的实例对象来表示，他们是Field、Method、Constructor、Package等等。

反射机制的优点与缺点

为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，
静态编译：在编译时确定类型，绑定对象,即通过。
动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，用以降低类之间的藕合性。
一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发。
它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

获得class对象

package com.nanchen.reflect;

public class ClassDemo {
    public static void main(String[] args) throws Exception {

        //获取Class对象的三种方法
        
        //1、类名.class--->String.class
        Class<String> c = String .class;
        
        //2、对象名.getClass--->new String().getClass()
        Class d = new String().getClass();
        
        //3、Class.forName("类名")----->Class.forName("java.lang.String");//反射主要用这种
        Class e = Class.forName("java.lang.String");
    }
}

 

反射----》获取Class中的构造方法Constuctor,方法Method,字段Filed

package com.nanchen.reflect;

public class Student {
    public long stuNo;
    public float score;
    private String name;
    private int age;
    
    public Student(){}
    public Student(String name,int age){
        this.name = name;
        this.age = 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;
    }
    private long getStuNo() {
        return stuNo;
    }
    private void setStuNo(long stuNo) {
        this.stuNo = stuNo;
    }
    private float getScore() {
        return score;
    }
    private void setScore(float score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [stuNo=" + stuNo + ", score=" + score + ", name="
                + name + ", age=" + age + "]";
    }
    
}

获取构造方法

package com.nanchen.reflect;

import java.lang.reflect.Constructor;

public class Demo2 {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.nanchen.reflect.Student");
        
        //获取public修饰的构造方法
        Constructor [] constructors = clazz.getConstructors();//获取所有为public的构造方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        
        System.out.println("------分割线---------");
        
        //获取指定的构造方法
        Constructor cs1 = clazz.getConstructor(String.class,int.class);
        System.out.println(cs1);
        
        System.out.println("------分割线---------");
        
        //获取所有的构造方法，public,private,protected等修饰的
        Constructor[] call = clazz.getDeclaredConstructors();
        for (Constructor constructor : call) {
            System.out.println(constructor);
        }
        
        //用获取的构造方法创建对象，有参和无参
        //有参的
        Student stu = (Student) clazz.getConstructor(String.class,int.class).newInstance("zhangsan",88);
        System.out.println(stu);
        
        System.out.println("------分割线---------");
        
        //无参的
        Student stu2 = (Student)clazz.getConstructor().newInstance();
        stu2.setAge(99);
        stu2.setName("lisi");
        System.out.println(stu2);
        
    }
}

   执行结果：

public com.nanchen.reflect.Student()
public com.nanchen.reflect.Student(java.lang.String,int)
------分割线---------
public com.nanchen.reflect.Student(java.lang.String,int)
------分割线---------
public com.nanchen.reflect.Student()
public com.nanchen.reflect.Student(java.lang.String,int)
Student [stuNo=0, score=0.0, name=zhangsan, age=88]
------分割线---------
Student [stuNo=0, score=0.0, name=lisi, age=99]

 

 

获取方法

package com.nanchen.reflect;

import java.lang.reflect.Method;

public class Demo3 {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.nanchen.reflect.Student");
        
        //获取public修饰的方法
        Method [] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("------分割线---------");
        
        //获取指定的方法
        Student stu = new Student();
        Method setNameMethod = clazz.getMethod("setName",String.class);
        setNameMethod.invoke(stu, "zhangsan");//第一个参数为此方法所在的对象，第二个参数为setName()方法需要传入的参数值
        System.out.println(stu.getName());
        
        System.out.println("------分割线---------");
        
        //获取所有的方法，不能获取继承的方法
        Method [] priMethods = clazz.getDeclaredMethods();
        for (Method method : priMethods) {
            System.out.println(method);
        }
        
        System.out.println("------分割线---------");
    
        //获取特定private修饰的方法
        Method setScoreMethod = clazz.getDeclaredMethod("setScore", float.class);
        setScoreMethod.setAccessible(true);//   启用/禁用  访问控制权限
        setScoreMethod.invoke(stu, (float)88.5);
        
        Method getScoreMethod = clazz.getDeclaredMethod("getScore", null);
        getScoreMethod.setAccessible(true);//   启用/禁用  访问控制权限
        float score = (float) getScoreMethod.invoke(stu, null);
        System.out.println(score);
    }

}

  执行结果：

public java.lang.String com.nanchen.reflect.Student.toString()
public java.lang.String com.nanchen.reflect.Student.getName()
public void com.nanchen.reflect.Student.setName(java.lang.String)
public int com.nanchen.reflect.Student.getAge()
public void com.nanchen.reflect.Student.setAge(int)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
------分割线---------
zhangsan
------分割线---------
public java.lang.String com.nanchen.reflect.Student.toString()
public java.lang.String com.nanchen.reflect.Student.getName()
public void com.nanchen.reflect.Student.setName(java.lang.String)
private void com.nanchen.reflect.Student.setScore(float)
private float com.nanchen.reflect.Student.getScore()
public int com.nanchen.reflect.Student.getAge()
public void com.nanchen.reflect.Student.setAge(int)
private long com.nanchen.reflect.Student.getStuNo()
private void com.nanchen.reflect.Student.setStuNo(long)
------分割线---------
88.5

 

 

获取字段

package com.nanchen.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Type;

public class Demo4 {
    public static void main(String[] args) throws Exception {
        Student stu = new Student();
        
        //获取public修饰的字段
        Field[] fields = stu.getClass().getFields();
        for (Field field : fields) {
            System.out.println(field);
            
            if(field.getType() == float.class)
                field.set(stu, (float)88.5);//为此字段赋值
            
            if(field.getType() == long.class)
                field.set(stu, 123456);//为此字段赋值
        }
        System.out.println(stu);
        
        System.out.println("------分割线---------");
        
        //获取private修饰的字段，并为其赋值
        Field nameField = stu.getClass().getDeclaredField("name");
        
        Type type = nameField.getType();//查看其类型
        System.out.println(type);
        
        nameField.setAccessible(true);//   启用/禁用  访问控制权限
        nameField.set(stu, "zhangsan");
        String name = (String)nameField.get(stu);//获得name字段的值
        System.out.println(name);
    }

}

   执行结果：

public long com.nanchen.reflect.Student.stuNo
public float com.nanchen.reflect.Student.score
Student [stuNo=123456, score=88.5, name=null, age=0]
------分割线---------
class java.lang.String
zhangsan