java反射基本使用操做

反射的基本原理：反射的機制是經過類加載器將字節碼文件讀入到內存中，而後經過解析器在內存中解析出這個類的全部東西，當咱們須要用到的時候咱們能夠拿出來使用。

1、反射一個類的構造函數

person類

package com.cn.ljh.reflect;

public class Person {

    private String name;
    private int age;
    //無參構造函數
    public Person(){
        System.out.println("無參構造函數");
    }
    //一個參數的構造函數
    public Person(String name){
        this.name = name;
        System.out.println("一個參數構造函數"+name);
    }
    
    //兩個構造函數
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println(name+"="+age);
    }
    
    //私有構造函數
    private Person(int age){
        this.age = age;
        System.out.println("私有的構造函數"+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;
    }
    
    
    
}

反射person類中的構造函數基本操做

package com.cn.ljh.reflect;

import java.lang.reflect.Constructor;

/**
 * 經過反射獲取構造函數
 * @author lijunhong
 *
 */
public class Test1 {

    
    public static void main(String[] args) throws Exception {
//      test1();
//      test2();
//      test3();
        test4();
    }
    
    //獲取字節碼文件的三種方式
    public static void test() throws Exception{
        //1.經過類的全名獲取
        Class clas = Class.forName("com.cn.ljh.reflect.Person");
        //2.經過類名獲取
        Class p = Person.class;
        //3.經過對象獲取
        Person person = new Person();
        Class cl = person.getClass();
    }
    
    //經過反射獲取無參構造函數(能夠使用上面三種方式獲取字節碼)
    public static void test1() throws Exception{
        //得到（Person）字節碼文件
        Class clas = Class.forName("com.cn.ljh.reflect.Person");
        //獲得無參構造函數
        Constructor con = clas.getConstructor(null);
        //經過無參構造函數建立實例
        Person persong = (Person) con.newInstance(null);
    }
    
    //經過反射獲取帶一個參數的構造函數
    public static void test2() throws Exception{
        
        //得到（Person）字節碼文件
        Class clas = Person.class;
        //獲得有一個參數的構造函數
        Constructor con = clas.getConstructor(String.class);
        //建立帶有一個參數的構造函數的實例
        Person p = (Person) con.newInstance("張三");
    }
    
    //經過反射獲取帶有兩個參數的構造函數
    public static void test3() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person");
        Constructor con = clas.getConstructor(String.class,int.class);
        con.newInstance("李白",100);
    }

    
    //經過反射獲取私有的構造函數
    public static void test4() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person");
        //獲取私有的構造函數
        Constructor con = clas.getDeclaredConstructor(int.class);
        con.setAccessible(true);//這裏設置爲true得到私有方法
        con.newInstance(100);
    }
}

2、反射一個類的方法

person2類

package com.cn.ljh.reflect;

public class Person2 {
    
    private String name;
    private int age;
    
    public Person2(){
        
    }
    
    public void eat1(){
        System.out.println("無參，無返回值方法");
    }
    
    public void eat2(String food,String toos){
        System.out.println("用"+toos+"(有參，無返回值)吃"+food);
    }
    
    public String eat3(){
        return "返回值方法";
    }
    
    private void eat4(){
        
        System.out.println("私有方法（無返回值，無參數）");
    }
    
    public static void main(String[] args){
        System.out.println("main函數");
        for(String s:args){
            System.out.println(s);
        }
    }
    
    

}

反射person2類中的方法基本操做

package com.cn.ljh.reflect;

import java.lang.reflect.Method;

/**
 * 經過反射獲取方法
 * @author lijunhong
 *
 */
public class Test2 {

    public static void main(String[] args) throws Exception {
//      test1();
//      test2();
//      test3();
//      test4();
        test5();
    }
    
    //反射無參無返回值方法
    public static void test1() throws Exception{
        //獲取（Person1)字節碼文件
        Class clas = Class.forName("com.cn.ljh.reflect.Person2");
        //經過無參構造函數建立對象
        Person2 p = (Person2) clas.newInstance();
        //得到方法(經過方法名字和參數反射）
        Method m = clas.getMethod("eat1", null);
        //經過對象和參數調用方法
        m.invoke(p, null);
    }
    
    //反射有參無返回值方法(多參數)
    public static void test2() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person2");
        Person2 p = (Person2) clas.newInstance();
        Method m = clas.getMethod("eat2", String.class,String.class);
        m.invoke(p, "香蕉","手");
    }
    
    //反射有返回值方法
    public static void test3() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person2");
        Method m = clas.getMethod("eat3", null);
        Person2 p = (Person2) clas.newInstance();
        String value = (String) m.invoke(p, null);
        System.out.println(value);
    }
    
    //反射私有方法
    public static void test4() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person2");
        Method m = clas.getDeclaredMethod("eat4", null);
        Person2 p = (Person2) clas.newInstance();
        //設置true獲得私有方法
        m.setAccessible(true);
        m.invoke(p, null);
    }
    
    //反射main方法
    public static void test5() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Person2");
        Method m = clas.getMethod("main", String[].class);
        Person2 p = (Person2) clas.newInstance();
        //將String數組封裝成Object數組，使其Object中只有一個元素，
        //不然main方法會將其拆成兩個參數，而不是一個數組元素
        //還能夠直接封裝成object類型的
//      m.invoke(p,new Object[]{(new String[]{"1","2"})});
        //封裝成object類型的
        m.invoke(p, (Object) new String[]{"1","2"});
    }

}

3、反射一個類的字段（成員變量）

student類

package com.cn.ljh.reflect;

public class Student {
    
    private String name;
    public int age;
    private static int grade;
    
    public Student(){
        
    }
    
    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;
    }
    public static int getGrade() {
        return grade;
    }
    public static void setGrade(int grade) {
        Student.grade = grade;
    }
    
    
}

反射一個類的字段的基本操做

package com.cn.ljh.reflect;

import java.lang.reflect.Field;

/**
 * 經過反射獲取字段
 * @author lijunhong
 *
 */
public class Test3 {

    public static void main(String[] args) throws Exception {
//      test1();
        test2();
//      test3();
    }
    
    //獲取私有字段(同時操做name字段）
    public static void test1() throws Exception{
        //得到student字節碼文件
        Class clas = Class.forName("com.cn.ljh.reflect.Student");
        //得到字段
        Field f = clas.getDeclaredField("name");
        //設置true拿到私有成員
        f.setAccessible(true);
        //建立對象
        Student s = (Student) clas.newInstance();
        //設置name的值
        f.set(s, "張三");
        //得到name的值
        String name = (String) f.get(s);
        System.out.println(name);
    }
    
    //獲取公共的字段（同時操做age字段）
    public static void test2() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Student");
        Student s = (Student) clas.newInstance();
        Field f = clas.getField("age");
        f.set(s, 12);
        System.out.println(f.get(s));
    }
    
    //獲取私有的靜態字段（同時操做grade字段）
    public static void test3() throws Exception{
        Class clas = Class.forName("com.cn.ljh.reflect.Student");
        Student s = (Student) clas.newInstance();
        s.getGrade();
        s.setGrade(12);
    }
    
}

記錄學習的每一步，記錄每一次的成長！！！！