Java基礎(chǔ)之反射技術(shù)相關(guān)知識(shí)總結(jié)

更新時(shí)間：2021年05月25日 14:54:09 作者：無名終將勝有名

今天帶大家復(fù)習(xí)Java基礎(chǔ)知識(shí),文中對(duì)Java反射技術(shù)介紹的非常詳細(xì),對(duì)正在學(xué)習(xí)Java的小伙伴們很有幫助,,需要的朋友可以參考下

一、反射概念

Java的反射（reflection）機(jī)制是指在程序的運(yùn)行狀態(tài)中，可以構(gòu)造任意一個(gè)類的對(duì)象，可以了解任意一個(gè)對(duì)象所屬的類，可以了解任意一個(gè)類的成員變量和方法，可以調(diào)用任意一個(gè)對(duì)象的屬性和方法。這種動(dòng)態(tài)獲取程序信息以及動(dòng)態(tài)調(diào)用對(duì)象的功能稱為Java語言的反射機(jī)制。反射被視為動(dòng)態(tài)語言的關(guān)鍵。

二、反射應(yīng)用場(chǎng)景

1.幾乎所有的框架都會(huì)用到反射

2.程序解耦合使用

3.代碼更加的優(yōu)雅

三、反射更多細(xì)節(jié)

1.Jdk中的位置: java.lang.reflect包下

在這里插入圖片描述

2.獲取字節(jié)碼方式

// 通過類的全限定類名獲取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 通過類直接獲取
Class<Hero> clazzB = Hero.class;
// 通過實(shí)例化對(duì)象獲取
Class<? extends Hero> clazzC = (new Hero()).getClass();
// 基本類型的包裝類的type獲取
Class<Byte> byteClazz = Byte.TYPE;
Class<Short> typeClazz = Short.TYPE;
Class<Integer> integerClazz = Integer.TYPE;
Class<Long> longClazz = Long.TYPE;
Class<Float> floatClazz = Float.TYPE;
Class<Double> doubleClazz = Double.TYPE;
Class<Character> characterClazz = Character.TYPE;
Class<Boolean> booleanClazz = Boolean.TYPE;

3.測(cè)試類Hero省略Setter和Getter以及toString方法其中包含無參構(gòu)造和滿參構(gòu)造

package com.open_source.demo.domain;

/**
 * 英雄實(shí)體類
 *
 * @author: tyvek
 */
public class Hero {
    /**
     * 類型
     */
    private String type;
    /**
     * 姓名
     */
    private String name;
    /**
     * 戰(zhàn)力
     */
    private Double CE;

    /**
     * 打印英雄屬性
     *
     * @param hero 英雄對(duì)象
     */
    public void attrbute(Hero hero) {
        System.out.println(hero.getType() + ": " + hero.getName() + "輸出傷害： " + hero.getCE());
    }

    /**
     * 為隊(duì)友加油
     */
    public void fighting() {
        System.out.println("穩(wěn)住 我們能贏");
    }

    /**
     * 向英雄發(fā)起進(jìn)攻
     *
     * @param name 英雄名字
     */
    public void attack(String name) {
        System.out.println("準(zhǔn)備向" + name + "發(fā)起進(jìn)攻");
    }

    public Hero(String type, String name, Double CE) {        
        this.type = type;
        this.name = name;
        this.CE = CE;
    }

    public Hero() {
    }
}

4.獲取類的成員

獲取類的構(gòu)造函數(shù)

import java.util.StringJoiner;

/**
 * 反射測(cè)試類
 * @author: tyvek
 */
public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通過類的全限定類名獲取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 獲取所有構(gòu)造函數(shù)字節(jié)碼
        Constructor<?>[] declaredConstructors = clazzA.getDeclaredConstructors();
        // 打印構(gòu)造函數(shù)修飾符以及參數(shù)類型
        for (int i = 0; i < declaredConstructors.length; i++) {
            // 美化輸出
            StringJoiner sj = new StringJoiner(", ","[","]");
            System.out.print("構(gòu)造函數(shù)修飾符：" + Modifier.toString(declaredConstructors[i].getModifiers()) + "  參數(shù)類型：");
            Class<?>[] parameterTypes = declaredConstructors[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 打印內(nèi)容  
構(gòu)造函數(shù)修飾符：public  參數(shù)類型：[java.lang.String, java.lang.String, java.lang.Double] 
構(gòu)造函數(shù)修飾符：public  參數(shù)類型：[]

獲取指定構(gòu)造函數(shù)

// 通過類的全限定類名獲取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 獲取滿參構(gòu)造
Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
// 獲取無參構(gòu)造
Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();

調(diào)用構(gòu)造函數(shù)

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通過類的全限定類名獲取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 獲取滿參構(gòu)造
        Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
        // 獲取無參構(gòu)造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        // 如果修飾符為private需要使用暴力反射
        // noneArgConstructor.setAccessible(true);
        Hero hero = (Hero) noneArgConstructor.newInstance();
        hero.setType("射手");
        hero.setName("后裔");
        hero.setCE(1000.0);
        System.out.println(hero);
        Hero heroAll = (Hero) allArgsConstructor.newInstance("法師", "諸葛亮", 1000.1);
        heroAll.attrbute(heroAll);
    }
}
// 控制臺(tái)輸出
Hero{type='射手', name='后裔', CE=1000.0}
法師: 諸葛亮 輸出傷害： 1000.1

獲取成員方法

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通過類的全限定類名獲取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 獲取無參構(gòu)造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        Hero hero = (Hero) noneArgConstructor.newInstance();
        // 獲取所有成員方法
        Method[] declaredMethods = clazzA.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            StringJoiner sj = new StringJoiner(",", "[", "]");
            System.out.print("方法名稱：" + declaredMethods[i].getName() + " 方法參數(shù): ");
            Class<?>[] parameterTypes = declaredMethods[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 控制臺(tái)輸出
方法名稱：attrbute 方法參數(shù): [com.open_source.demo.domain.Hero]
方法名稱：attack 方法參數(shù): [java.lang.String]
set和get省略

方法調(diào)用

// 獲取attack字節(jié)碼對(duì)象
Method attackMethod = clazzA.getDeclaredMethod("attack", String.class);
// 如果修飾符為private同樣需要使用暴力反射
attackMethod.invoke(hero,"周瑜");
// 控制臺(tái)輸出
準(zhǔn)備向周瑜發(fā)起進(jìn)攻

獲取所有的成員屬性

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通過類的全限定類名獲取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 獲取所有成員屬性
        Field[] declaredFields = clazzA.getDeclaredFields();
        Stream.of(declaredFields).forEach(System.out::println);
    }
}
// 控制臺(tái)輸出
private java.lang.String com.open_source.demo.domain.Hero.type
private java.lang.String com.open_source.demo.domain.Hero.name
private java.lang.Double com.open_source.demo.domain.Hero.CE

獲取父類的字節(jié)碼

// 通過類的全限定類名獲取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero").getSuperclass();

反射工具類

package com.open_source.demo.support;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * @author: tyvek
 * 反射工具類
 */
public class ReflectSupport {
    private ReflectSupport(){};

    /**
     * 獲取字段對(duì)應(yīng)值，并轉(zhuǎn)為String類型，空值返回空字符串
     * @param fieldName
     * @param obj
     * @return
     */
    public static synchronized String getStringValue(String fieldName,Object obj) throws  ReflectiveOperationException{
        Object objectValue = getValueByGetter(fieldName,obj);
        if (objectValue == null){
            return "";
        }
        String result = objectValue.toString();
        //如果類型為BigDecimal,去掉末尾的0
        if (objectValue instanceof BigDecimal){
            BigDecimal value = (BigDecimal) objectValue;
            value = value.stripTrailingZeros();
            result = value.toPlainString();
        }else if (objectValue instanceof Date){
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            result = sdf.format((Date)objectValue).replace(" 00:00:00", "");
        }

        return result.trim();
    }

    public static Object getValueByGetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method getter = getGetter(fieldName, obj.getClass());
        if (getter != null){
            return getter.invoke(obj);
        }

        return null;
    }


    public static Object setValueBySetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method setter = getSetter(fieldName, obj.getClass());
        if (setter == null){
            throw new ReflectiveOperationException("沒有set方法");
        }

        return setter.invoke(obj);
    }

    /**
     * 獲取get方法
     * @param fieldName
     * @param cls
     * @return
     */
    public static Method getGetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("get".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    /**
     * 獲取set方法
     * @param fieldName
     * @param cls
     * @return
     */
    public static Method getSetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("set".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    /**
     * 通過屬性名獲取Field對(duì)象
     * @param fieldName
     * @param cls
     * @return
     */
    public static synchronized Field getFieldByName(String fieldName,Class<?> cls){
        Field[] fields =cls.getDeclaredFields();
        for (Field field : fields){
            if (field.getName().equals(fieldName)){
                return field;
            }
        }

        if (cls.getSuperclass() != null){
            return getFieldByName(fieldName,cls.getSuperclass());
        }

        return null;
    }

    /**
     * 通過對(duì)象.class獲取所有Fields，包括父類
     * @param cls
     * @return
     */
    public static List<Field> listFields(Class<?> cls){
        Field[] fs = cls.getDeclaredFields();
        List<Field> fields = new ArrayList<>(Arrays.asList(fs));
        if (cls.getSuperclass() !=null){
            fields.addAll(listFields(cls.getSuperclass()));
        }
        return fields;
    }

    public static  boolean fieldExist(String fieldName,Class<?> cls){
        return getFieldByName(fieldName, cls) !=null;
    }
}

到此這篇關(guān)于Java基礎(chǔ)之反射技術(shù)相關(guān)知識(shí)總結(jié)的文章就介紹到這了,更多相關(guān)Java反射技術(shù)內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: