JAVA學習之-反射

阿新 • • 發佈：2020-06-29

一，類物件

類的物件：基於某個類new出來的物件，也叫例項物件
類物件：類載入的產物，封裝了一個類所有的資訊（類名，父類，介面，屬性，方法，構造方法）Java原始碼編譯後的.class檔案儲存在硬碟中，從硬碟載入進記憶體。就是一個類物件
將類的各個組成部分封裝為其他物件，就是反射機制

反射的好處：

1.可以在程式執行過程中，操作這些物件。
2.可以解耦，提高程式的可擴充套件性。

1.1Java程式碼在計算機中的三個階段

1.2 獲取Class物件的方式：

Class.forName("包名.類名")：將位元組碼檔案載入進記憶體，返回Class物件 * 多用於配置檔案，將類名定義在配置檔案中。讀取檔案，載入類 推薦寫法
類名.class：通過類名的屬性class獲取，返回Class物件 * 多用於引數的傳遞
物件.getClass()：getClass()方法在Object類中定義著。* 多用於物件的獲取位元組碼的方式

同一個位元組碼檔案(*.class)在一次程式執行過程中，只會被載入一次，不論通過哪一種方式獲取的Class物件都是同一個。

通用操作：

使用反射機制獲取類物件，並使用Class物件的方法獲取表示類成員的各種物件（Constructor，Method，Field），實現反射各種應用

案例，

package com.qf;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Properties;

 
public class TestStudent {
    
    public static void main(String[] args) throws Exception {
        //getClazz();
        //getClazzInfo();
//        getConstructors();
        // getMethods();
        
//        Properties properties=new Properties();
//        ArrayList<String> arrayList=new ArrayList<String>();
 
//        //properties.setProperty(key, value)
//        properties.setProperty("username", "張三");
//        invokeAny(properties, "setProperty", new Class<?>[] {String.class,String.class}, new Object[] {"username","張三"});
//        invokeAny(arrayList, "add", new Class<?>[] {Object.class}, new Object[] {"梓源"});
//        System.out.println(properties);
//        System.out.println(arrayList);
        
        //getFields();
        testIntrospector();
        
    }
    
    //獲取類物件
    public static void getClazz() throws Exception {
        //(1)通過類的物件，呼叫getClass()方法
        Student xiangrui=new Student();
        Class<?> class1= xiangrui.getClass();
        System.out.println(class1.hashCode());
        //(2)通過類名.class
        Class<?> class2=Student.class;
        System.out.println(class2.hashCode());
        //(3)通過Class.forName()靜態方法獲取,引數是類的全名稱, 推薦寫法：(1)靈活 (2)耦合性低
        Class<?> class3=Class.forName("com.qf.Student");
        System.out.println(class3.hashCode());
    }
    //獲取類名、包、父類、實現介面
    public static void getClazzInfo() throws Exception {
        //1獲取類物件
        Class<?> class1=Class.forName("com.qf.Student");
        //2獲取類的全名稱
        System.out.println(class1.getName());
        //3獲取包資訊
        Package package1 = class1.getPackage();
        System.out.println(package1.getName());
        //4獲取父類
        Class<?> superclass = class1.getSuperclass();
        System.out.println(superclass.getName());
        System.out.println("-----------------");
        //5獲取實現介面
        Class<?>[] interfaceClasses=class1.getInterfaces();
        for (Class<?> class2 : interfaceClasses) {
            System.out.println(class2);
        }
    }
    
    //獲取類的構造方法【重點】
    public static void getConstructors() throws Exception {
        //1 獲取類物件
        Class<?> class1=Class.forName("com.qf.Student");
        //2獲取構造方法
        //2.1getConstructors()獲取所有的構造方法
//        Constructor<?>[] constructors=class1.getConstructors();
//        for (Constructor<?> constructor : constructors) {
//            System.out.println(constructor);
//        }
        //2.2獲取無參構造方法
        Constructor<?> constructor=class1.getConstructor();
        //使用無參構造方法建立物件
        Student student=(Student)constructor.newInstance();
        System.out.println(student);
        //2.3獲取帶參構造方法
        Constructor<?> constructor2=class1.getConstructor(String.class,int.class,String.class,String.class);
        //使用帶參構造方法建立物件
        Student xiangrui=(Student)constructor2.newInstance("祥睿",20,"1001","男");
        System.out.println(xiangrui);
        
        //3建立物件的簡便方法(預設是無參構造方法)
        Student student2=(Student)class1.newInstance();
        System.out.println(student2);
    
    }

    //獲取類的普通方法【重點】
    public static void getMethods() throws Exception{
        //獲取類物件
        Class<?> class1=Class.forName("com.qf.Student");
        //1獲取所有方法 getMethods()獲取所有公開的方法，包括繼承的公開方法
        //Method[] methods=class1.getMethods();
        //2獲取所有方法 getDeclaredMethods(); 獲取類中所有的方法，包括私有、保護、預設方法、不包括繼承的方法。
//        Method[] methods=class1.getDeclaredMethods();
//        for (Method method : methods) {
//            System.out.println(method);
//        }
        //3獲取show方法
        Method methodShow=class1.getMethod("show");
        //呼叫方法
//        Student student=new Student();
//        student.show();
        Student student=(Student)class1.newInstance();
        methodShow.invoke(student);//student.show();
        
        //獲取帶參show方法
        Method methodShow2=class1.getMethod("show",String.class);
        methodShow2.invoke(student, "110");
        
        //獲取getName()方法
        Method methodGetName=class1.getMethod("getName");
        String name=(String)methodGetName.invoke(student);
        System.out.println(name);
        
        //獲取靜態方法
        Method methodPrintInfo=class1.getMethod("printInfo");
        methodPrintInfo.invoke(null);//Student.printInfo();
        //獲取私有方法
        Method methodPrintInfo2=class1.getDeclaredMethod("printInfo2");
        //設定訪問許可權無效(不要用，破壞封裝性)
        methodPrintInfo2.setAccessible(true);
        methodPrintInfo2.invoke(student);
        
    }

    //通用方法
    public static Object invokeAny(Object obj,String methodName,Class<?>[] paramsType,Object... paramsValue) throws Exception {
        Class<?> class1=obj.getClass();
        Method method=class1.getMethod(methodName, paramsType);
        return method.invoke(obj, paramsValue);
    }
    
    //使用反射操作屬性
    public static void getFields() throws Exception {
        //獲取類物件
        Class<?> class1 = Class.forName("com.qf.Student");
        //獲取屬性
        //getFields() 獲取公開的屬性、從父類繼承的屬性
        //class1.getFields()
//        Field[] fields=class1.getDeclaredFields();
//        for (Field field : fields) {
//            System.out.println(field);
//        }
        //獲取name
        Field fieldName=class1.getDeclaredField("name");
        Student ziyuan = (Student)class1.newInstance();
        
        //呼叫
        fieldName.setAccessible(true);
        fieldName.set(ziyuan, "梓源");
        System.out.println(fieldName.get(ziyuan));
        
        Field fieldAge=class1.getDeclaredField("age");
        fieldAge.setAccessible(true);
        fieldAge.set(ziyuan, 20);
        System.out.println(fieldAge.get(ziyuan));
    
    }
    
    //內省機制：使用反射技術操作屬性的一種機制。
    //Introspector 內省工具類
    //BeanInfo 類資訊
    //PropertyDescriptor 屬性描述符(代表一個屬性)
    //以getXxx  setXxx  isXxx開頭的方法叫屬性
    
    public static void testIntrospector() throws Exception {
        Class<?> class1=Class.forName("com.qf.Teacher");
        //BeanInfo 類資訊
        //BeanInfo beanInfo = Introspector.getBeanInfo(class1);
        //PropertyDescriptor 
        //以getXxx  setXxx  isXxx開頭的方法叫屬性
//        PropertyDescriptor[] propertyDescriptors=beanInfo.getPropertyDescriptors();
//        for (PropertyDescriptor pd : propertyDescriptors) {
//            System.out.println(pd.getName());
//        }
        
        Teacher lilaoshi=(Teacher)class1.newInstance();
        //獲取屬性描述符
        PropertyDescriptor pdName=new PropertyDescriptor("name", class1);
        PropertyDescriptor pdAge=new PropertyDescriptor("age", class1);
        PropertyDescriptor pdSalary=new PropertyDescriptor("salary", class1);
        
        //賦值
        pdName.getWriteMethod().invoke(lilaoshi, "李老師");//setName();
        pdAge.getWriteMethod().invoke(lilaoshi, 40);
        pdSalary.getWriteMethod().invoke(lilaoshi, 50000);
        
        System.out.println(lilaoshi);
        
        System.out.println(pdName.getReadMethod().invoke(lilaoshi));
        
    }
    
}

1.2 java建立物件的四種方式：

使用new關鍵字，呼叫構造方法
使用反射技術，呼叫構造方法
使用Cloneable介面克隆物件，不會呼叫構造方法，必須實現介面重寫clone方法
使用反序列化，不會呼叫構造方法，實現serializable介面

1.3 設計模式

特定問題的固定解決辦法，程式碼設計經驗的總結
Gof設計模式中，介紹了23種
好處是可重用，

1.4 工廠設計模式

開閉原則，對拓展開放，對修改關閉
工廠模式主要負責物件的建立問題
可通過反射進行工廠模式的設計，動態完成物件建立

1.5 單例設計模式

1.5.1餓漢式寫法：缺點：宣告週期比較長，浪費空間。優點：執行緒安全

把類的構造方法變為私有的。
在單例類內部類建立物件並例項化
在單例類中新增一個公開的方法，返回這個物件

 1 //餓漢式
 2 public class SingleTon1{
 3     private SingleTon1(){
 4 
 5     }
 6     private static final SingleTon1 instance = new SingleTon1();
 7    
 8   public static SingleTon1 getInstance(){
 9       return instance;
10     }
11 }

1.5.2 懶漢式寫法：懶漢式寫法: 優點:宣告週期短，節省空間缺點：執行緒不安全

把類的構造方法變為私有的。
在單例類內部類建立物件，沒有初始化。
在單例類中新增一個公開的方法，返回這個物件

public class SingleTon2 {
    // (1)把類的構造方法變為私有的。
    private SingleTon2() {
    
    }
    //(2)在單例類內部類建立物件，沒有初始化。
    private static SingleTon2 instance=null;
    
    //(3)在單例類中新增一個公開的方法，返回這個物件
    
    public static SingleTon2 getInstance() { //100執行緒 ，只要有一個執行緒進入到synchronized中，instance一定例項化了,另外99個執行緒不需要判斷synchronized
        if(instance==null) {//提高效率 另外99判斷if
            synchronized (SingleTon2.class) {
                if(instance==null) {
                    instance=new SingleTon2();
                }
            }
        }
        return instance;
    }
}

1.5.3 靜態內部類寫法

public class SingleTon3 {
    //1私有化構造方法
    private SingleTon3() {
        // TODO Auto-generated constructor stub
    }
    //2建立物件(1 靜態內部類不使用，不會提前載入，宣告週期短，2 JVM例項化物件時解決執行緒安全問題)
    private static class Holder{
        private static final SingleTon3 instance=new SingleTon3();
    }
    //3返回這個物件
    public static SingleTon3 getInstance() {
        return Holder.instance;
    }
}

二，列舉

引用型別，規定了取值範圍的資料型別
列舉變數不能使用其他的資料，只能使用列舉中的常量賦值，提高程式安全性
定義列舉使用enum關鍵字
列舉的本質：

是一個終止類，繼承Enum抽象類
列舉中常量是當前型別的靜態常量

/**
 * 定義列舉
 * 關鍵字enum  (Enumeration)
 * 包含 
 * 1 【常量】 ;可以省略
 * 2 【私有構造方法、屬性、方法】必須在常量的後面寫
 * @author wgy
 *
 */
public enum Gender {

    //1【常量】
    MALE,FEMALE;
    
    //2 【私有構造方法、屬性、方法】必須在常量的後面寫
    private Gender() {
        
    }
    private int value;
    
    public void show() {
        System.out.println(value);
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

}

三，註解

註解（Annotation），也叫元資料。一種程式碼級別的說明。它是JDK1.5及以後版本引入的一個特性，與類、介面、列舉是在同一個層次。它可以宣告在包、類、欄位、方法、區域性變數、方法引數等的前面，用來對這些元素進行說明，註釋。
程式可以讀取註解，一般用於代替配置檔案
通過反射技術獲取註解，決定怎麼執行類

3.1 定義註解

@interface關鍵字，註解中只能包含屬性

3.2 註解屬性型別

1 基本型別
2 String
3 Class型別
4 列舉型別
5 註解型別
以及上述型別的一維陣列

@Retention(value=RetentionPolicy.RUNTIME)
//@Target({ElementType.METHOD,ElementType.TYPE,ElementType.FIELD})
public @interface MyAnnotation {
    //public 屬性
    String name() default "張三";
    int age();
    String address();
    
}

3.3 元註解

用來描述註解的註解

JAVA學習之-反射

一，類物件類的物件：基於某個類new出來的物件，也叫例項物件類物件：類載入的產物，封裝了一個類所有的資訊（類名，父類，介面，屬性，方法，構造方法）Java原始碼編譯後的.class檔案儲存在硬碟中，從硬碟載入進

Java進階學習之反射與動態繫結（5）

目錄 1.反射 1.1.概述 1.2.實現方式 1.2.1.獲取Class 1.2.2.通過反射獲取屬性、設定屬性

Java基礎之反射原理與用法詳解

本文例項講述了Java基礎之反射原理與用法。分享給大家供大家參考，具體如下：

java學習之基礎（1）

java 學習之路 0x00 前言學習java也有段時間了，寫篇文章來記錄一下學習內容。

Java學習之面向物件篇

Java學習之面向物件篇 0X00 前言前面講了java的一些基本語法，這裡就來講講java的核心思想，面向物件。

Java學習之繼承與抽象篇

Java學習之繼承與抽象篇 0x00 前言前面講到了面向物件，面向物件的三大特性是封裝、繼承、多型。那麼這次就來講講繼承。

Java學習之介面與多型篇

Java學習之介面與多型篇 0x00 前言在前面寫的幾篇文章裡，講了封裝和繼承，那麼這篇文章就來講講第三大面向物件的特性多型吧，在此之前先接著上篇文章的抽象先來看看Java裡面介面的應用。

Java學習之final與匿名內部類

Java學習之final與匿名內部類 0x00 前言續上幾篇文章，得知子類繼承父類後是可以在父類的基礎上進行改寫的，那麼在程式中有些東西可能是不能讓我們給輕易給改動的，那麼Java給提供了final關鍵字。

Java學習之常用類篇

Java學習之常用類篇 0x00 前言在開發中難免呼叫到各種api來開發程式，那就先來學習一下api的一些相關概念。

Java學習之集合篇

Java學習之集合篇 0x00 前言上篇文章的常用類，其實就已經講到了，這個ArrayList集合，但是ArrayList只是集合中的其中一種，那這篇文章就來講講關於集合的一些物件。

Java學習之檔案io流篇

Java學習之檔案io流篇 0x00 前言在平時的一些開發中，普遍都會讓指令碼執行的時候，去儲存一些指令碼執行結果的資料，例如開發一個爬蟲，這時候我們爬取下來的內容，就需要儲存到本地，那麼這時候就會用到一些操作檔

Java學習之註解篇

Java學習之註解篇 0x00 前言續上篇文章，這篇文章就來寫一下註解的相關內容。

Java學習之Request篇

Java學習之Request篇 0x00 前言在b/s架構裡面，請求和響應是必不可少的。訪問網頁時，會發出一個request請求，伺服器接收到請求後，根據設定程式碼，給我們響應對應的內容。

初探java安全之反射

什麼是反射反射機制在java中可以說是非常強大的，很多優秀的開源框架都是通過反射完成的。在java的執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法，都能夠呼叫它的任意一個方法和屬性，這種動態獲取

Java學習之Spring MVC入門

Java學習之Spring MVC入門 0x00 前言前面寫了SSM 的兩大框架，分別是Mybatis和Spring，這裡來寫一下Spring MVC框架的相關內容。

Java學習之spring MVC常用註解

Java學習之spring MVC常用註解 0x00 前言續上篇文章的內容繼續來記錄spring mvc會常用到的一些註解。

Java學習之Spring Boot入門

Java學習之Spring Boot入門 0x00 前言學習完ssm的整合後，開始來學習Spring Boot，在前面學習Spring的時候會發現使用Spring開發中配置Spring的環境會非常的繁瑣，而Spring boot的出現就解決了這個問題。

Java學習之區塊

在建立一個物件時，會呼叫構造方法外還會執行其他區塊的語句，例如靜態塊、構造塊。

Java學習之繼承的奇思妙想

剛剛想到如果靜態內部類繼承了父類，那豈不是可以無限套娃了，然後就動手試了一下

Java學習之 ClassLoader類載入器

Java學習之 ClassLoader類載入器 0x00 前言前面這裡丟擲一個問題，Java到底是什麼型別的程式語言？是編譯型？還是解釋型？在這個問題是其實一直都都有疑惑，如果說是解釋型語言的話，那麼為什麼需要編譯呢？如果說是

JAVA學習之-反射

相關推薦