劉意老師整理

Junit單元測試：

測試分類：

黑盒測試：不需要寫代碼，給輸入值，看程序是否能夠輸出期望的值。
白盒測試：需要寫代碼的。關注程序具體的執行流程。

Junit使用：白盒測試

步驟：

1. 定義一個測試類(測試用例)

測試類名：被測試的類名Test CalculatorTest
包名：xxx.xxx.xx.test cn.itcast.test

2. 定義測試方法：可以獨立運行

方法名：test測試的方法名 testAdd()
返回值：void
參數列表：空參

3. 給方法加@Test

4. 導入junit依賴環境

判定結果：

紅色：失敗
綠色：成功

一般我們會使用斷言操作來處理結果

Assert.assertEquals(期望的結果,運算的結果)

補充：

@Before：

修飾的方法會在測試方法之前被自動執行

@After：

修飾的方法會在測試方法執行之後自動被執行

反射：框架設計的靈魂

框架：半成品軟件。可以在框架的基礎上進行軟件開發，簡化編碼
反射：將類的各個組成部分封裝爲其他對象，這就是反射機制

好處：

可以在程序運行過程中，操作這些對象。
可以解耦，提高程序的可擴展性。

獲取Class對象的方式：

Class.forName("全類名")：將字節碼文件加載進內存，返回Class對象

多用於配置文件，將類名定義在配置文件中。讀取文件，加載類

類名.class：通過類名的屬性class獲取

多用於參數的傳遞

對象.getClass()：getClass()方法在Object類中定義着。

多用於對象的獲取字節碼的方式

結論：

同一個字節碼文件(*.class)在一次程序運行過程中，只會被加載一次，不論通過哪一種方式獲取的Class對象都是同一個。

Class對象功能：

獲取成員變量們

Field[] getFields() ：獲取所有public修飾的成員變量
Field getField(String name)   獲取指定名稱的 public修飾的成員變量

Field[] getDeclaredFields()  獲取所有的成員變量，不考慮修飾符
Field getDeclaredField(String name)

獲取構造方法們

Constructor<?>[] getConstructors()  
Constructor<T> getConstructor(類<?>... parameterTypes)  

Constructor<T> getDeclaredConstructor(類<?>... parameterTypes)  
Constructor<?>[] getDeclaredConstructors()

獲取成員方法們

Method[] getMethods()  
Method getMethod(String name, 類<?>... parameterTypes)  

Method[] getDeclaredMethods()  
Method getDeclaredMethod(String name, 類<?>... parameterTypes)

獲取全類名

String getName()

Field：成員變量

設置值

void set(Object obj, Object value)

獲取值

get(Object obj)

忽略訪問權限修飾符的安全檢查

setAccessible(true):暴力反射

Constructor:構造方法

創建對象：T newInstance(Object... initargs)

如果使用空參數構造方法創建對象，操作可以簡化：Class對象的newInstance方法

Method：方法對象

執行方法：

Object invoke(Object obj, Object... args)

獲取方法名稱：

String getName:獲取方法名

案例：

需求：寫一個"框架"，不能改變該類的任何代碼的前提下，可以幫我們創建任意類的對象，並且執行其中任意方法

實現：

配置文件
反射

步驟：

將需要創建的對象的全類名和需要執行的方法定義在配置文件中
在程序中加載讀取配置文件
使用反射技術來加載類文件進內存
創建對象
執行方法

實體類

package cn.ly.domain;

public class Student {

    public void sleep(){
        System.out.println("sleep...");
    }
}

pro.properties

className=cn.ly.domain.Student
methodName=sleep

ReflectTest.java

package cn.ly.reflect;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTest {

    public static void main(String[] args) throws Exception {
        //加載配置文件
        Properties pro = new Properties();
        //獲取配置文件的輸入流
        InputStream is = ReflectTest.class.getClassLoader().getResourceAsStream("pro.properties");
        //將配置文件加載進內存
        pro.load(is);
        //取出配置文件的數據
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        //加載該類進內存
        Class cls = Class.forName(className);
        //創建對象
        Object obj = cls.newInstance();
        //獲取需要調用的方法對象
        Method method = cls.getMethod(methodName);
        //執行方法
        method.invoke(obj);
        is.close();

    }
}

註解

概念：說明程序的。給計算機看的

註釋：用文字描述程序的。給程序員看的

定義：註解（Annotation），也叫元數據。一種代碼級別的說明。它是JDK1.5及以後版本引入的一個特性，與類、接口、枚舉是在同一個層次。它可以聲明在包、類、字段、方法、局部變量、方法參數等的前面，用來對這些元素進行說明，註釋。

概念描述：

JDK1.5之後的新特性
說明程序的
使用註解：@註解名稱

作用分類：

編寫文檔：通過代碼裏標識的註解生成文檔【生成文檔doc文檔】
代碼分析：通過代碼裏標識的註解對代碼進行分析【使用反射】
編譯檢查：通過代碼裏標識的註解讓編譯器能夠實現基本的編譯檢查【Override】

JDK中預定義的一些註解

@Override ：檢測被該註解標註的方法是否是繼承自父類(接口)的
@Deprecated：該註解標註的內容，表示已過時
@SuppressWarnings：壓制警告
一般傳遞參數all @SuppressWarnings("all")

自定義註解

格式：

元註解
public @interface 註解名稱{
    屬性列表;
}

本質：註解本質上就是一個接口，該接口默認繼承Annotation接口

public interface MyAnno extends java.lang.annotation.Annotation {

}

屬性：接口中的抽象方法

格式要求：屬性的返回值類型有下列取值

基本數據類型
String
枚舉
註解
以上類型的數組

定義了屬性，在使用時需要給屬性賦值

如果定義屬性時，使用default關鍵字給屬性默認初始化值，則使用註解時，可以不進行屬性的賦值。
如果只有一個屬性需要賦值，並且屬性的名稱是value，則value可以省略，直接定義值即可。
數組賦值時，值使用{}包裹。如果數組中只有一個值，則{}可以省略

元註解：用於描述註解的註解

@Target：描述註解能夠作用的位置

ElementType取值：
TYPE：可以作用於類上
METHOD：可以作用於方法上
FIELD：可以作用於成員變量上

@Retention：描述註解被保留的階段

@Retention(RetentionPolicy.RUNTIME)：當前被描述的註解，會保留到class字節碼文件中，並被JVM讀取到

@Documented：描述註解是否被抽取到api文檔中

@Inherited：描述註解是否被子類繼承

在程序使用(解析)註解：獲取註解中定義的屬性值

使用註解來改良反射中的案例

ReflectTest.java

package cn.ly.annotation;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 框架類
 */

@Pro(className = "cn.ly.annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {

        /*
            前提：不能改變該類的任何代碼。可以創建任意類的對象，可以執行任意方法
         */

        //1.解析註解
        //1.1獲取該類的字節碼文件對象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.獲取上邊的註解對象
        //其實就是在內存中生成了一個該註解接口的子類實現對象
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        /*
            public class ProImpl implements Pro{
                public String className(){
                    return "cn.itcast.annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }
            }
        */
        //3.調用註解對象中定義的抽象方法，獲取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className);
        System.out.println(methodName);

        //4.加載該類進內存
        Class cls = Class.forName(className);
        //5.創建對象
        Object obj = cls.newInstance();
        //6.獲取方法對象
        Method method = cls.getMethod(methodName);
        //7.執行方法
        method.invoke(obj);
    }
}

Demo1.java

package cn.ly.annotation;

public class Demo1 {
    public void show(){
        System.out.println("demo1...show...");
    }
}

獲取註解定義的位置的對象（Class,Method,Field）

獲取指定的註解

getAnnotation(Class)

//其實就是在內存中生成了一個該註解接口的子類實現對象

public class ProImpl implements Pro{
    public String className(){
        return "cn.itcast.annotation.Demo1";
    }
    public String methodName(){
        return "show";
    }
}

調用註解中的抽象方法獲取配置的屬性值

案例：簡單的測試框架

Calculator.java

package cn.ly.annotation.demo;


/**
 * 小明定義的計算器類
 */
public class Calculator {

    //加法
    @Check
    public void add() {
        System.out.println("1 + 0 = " + (1 + 0));
    }

    //減法
    @Check
    public void sub() {
        System.out.println("1 - 0 = " + (1 - 0));
    }

    //乘法
    @Check
    public void mul() {
        System.out.println("1 * 0 = " + (1 * 0));
    }

    //除法
    @Check
    public void div() {
        System.out.println("1 / 0 = " + (1 / 0));
    }


    public void show() {
        System.out.println("永無bug...");
    }

}

註解Check

package cn.ly.annotation.demo;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}

TestCheck.java

package cn.ly.annotation.demo;


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 簡單的測試框架
 * <p>
 * 當主方法執行後，會自動自行被檢測的所有方法(加了Check註解的方法)，判斷方法是否有異常，記錄到文件中
 */
public class TestCheck {


    public static void main(String[] args) throws IOException {
        //1.創建計算器對象
        Calculator c = new Calculator();
        //2.獲取字節碼文件對象
        Class cls = c.getClass();
        //3.獲取所有方法
        Method[] methods = cls.getMethods();

        int number = 0;//出現異常的次數
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));

        for (Method method : methods) {
            //4.判斷方法上是否有Check註解
            if (method.isAnnotationPresent(Check.class)) {
                //5.有，執行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕獲異常
                    //記錄到文件中
                    number++;

                    bw.write(method.getName() + " 方法出異常了");
                    bw.newLine();
                    bw.write("異常的名稱:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("異常的原因:" + e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();
                }
            }
        }
        bw.write("本次測試一共出現 " + number + " 次異常");

        bw.flush();
        bw.close();
    }
}

小結：

以後大多數時候，我們會使用註解，而不是自定義註解
註解給編譯器和解析程序用
註解不是程序的一部分，可以理解爲註解就是一個標籤

Junit單元測試&反射&註解

劉意老師整理

Junit單元測試：

測試分類：

Junit使用：白盒測試

反射：框架設計的靈魂

獲取Class對象的方式：

Class對象功能：

獲取成員變量們

獲取構造方法們

獲取成員方法們

Field：成員變量

Constructor:構造方法

Method：方法對象

案例：

註解

自定義註解

屬性：接口中的抽象方法

元註解：用於描述註解的註解

在程序使用(解析)註解：獲取註解中定義的屬性值

案例：簡單的測試框架

小結：

記一次 .NET某工業設計軟件崩潰分析

創建 Vue3 項目

TS + Webpack 整合 Jest

分享5款.NET開源免費的Redis客戶端組件庫

安卓手機如何登錄抖音境外版

golang開發 gorilla websocket的使用

面試官：如果不允許線程池丟棄任務，應該選擇哪個拒絕策略？

Mac卸載 Node npm，升級 Node

嵌入式汽車電子學習路線

uni.showModel內容換行

Mybatis的dao層實現原理

Spring簡介和配置

javaScript之本地存儲

toDoList開發實例

CSS3開發案例

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結