junit單元測試及jdk5.0新特性:泛型、枚舉、靜態(tài)導入、自動拆裝箱、增強for循環(huán)、可變參數、反射

junit的使用：

單元測試：測試對象是類中的某個方法

junit不是JavaSE的一部分，需要導入jar包使用，但是myeclipse中自帶了junit的jar包。

junit有兩個版本，3.x和4.x，單元測試的時候方法命名規(guī)則為（方法不能帶任何參數）：public void 方法名(){}
使用注解的方式運行測試方法：在測試方法名上添加@Test

例：


項目工程組成

TestJunit.java文件內容：

package cn.itcast.test;

public class TestJunit {
    
    public void testAdd(int a, int b){
        System.out.println(a + b);
    }
}

TestDemo.java文件內容：

package cn.itcast.test;

import org.junit.Test;

public class TestDemo {
    //測試方法
    @Test
    public void testAdd(){
        TestJunit testJunit = new TestJunit();
        testJunit.testAdd(2, 3);        
    }
}

選中testAdd()函數，右鍵點擊選中RunAS->JunitTest，結果如下時測試通過：


image.png

要測試所有的方法，則直接點擊TestDemo文件的其他位置，右鍵點擊選中RunAS->JunitTest

注解：
@Test：表示參加單元測試
@Ignore：表示忽略，不參加單元測試
@Before：表示在每個帶有@Test注解方法的測試運行之前運行
@After：表示在每個帶有@Test注解方法的測試運行之后運行

斷言（了解）：
Assert.assertEquals(期望值, 測試函數運行實際值)；

jdk5.0新特性:

jdk版本：1.1 ，1.2，1.4，5.0
泛型、枚舉、靜態(tài)導入、自動拆裝箱、增強for循環(huán)、可變參數、反射

泛型簡介:

為什么使用泛型：


image.png

在集合上使用泛型：集合<類型>
List：List<String>
Set：Set<Element>
Map：Map<Double>
例：

package cn.itcast.test2;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class TestDemo2 {
    @Test
    public void testList(){
        List<String> l = new ArrayList<String>();
        l.add("AAA");
        l.add("BBB");
        l.add("CCC");
        for(String s : l){
            System.out.println(s);
        }
    }
}

注意：在泛型的<>中填的是類，不能填基本數據類型，應該填基本數據類型對應的包裝類
基本數據類型 -- 包裝類：
byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char -- Character
boolean -- Boolean

在方法上使用泛型：方法邏輯相同，只是數據類型不同，可使用泛型方法

package cn.itcast.test2;

import java.util.Arrays;

public class TestDemo3 {

    public static void main(String[] args) {
        Integer[] arr1 = {1, 2, 3, 4};
        String[] arr2 = {"a", "b", "c", "d"};
        
        System.out.println(Arrays.toString(arr1));
        Swap(arr1, 1, 3);
        System.out.println(Arrays.toString(arr1));
        
        System.out.println("-------------------------------");
        
        System.out.println(Arrays.toString(arr2));
        Swap(arr2, 1, 3);
        System.out.println(Arrays.toString(arr2));
    }

    private static <T> void Swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}
運行結果

在類上使用泛型：public class 類名<T> {}
注意：在類上使用的泛型定義的類型T不能在類中的靜態(tài)方法上使用。

枚舉的簡介：

枚舉概念：在一定范圍內取值，取值只能是該范圍類的一個值，例：紅綠燈的顏色。

package cn.itcast.test2;

public class TestEnum1 {
    
    private Color color;
    
    public void test(){
        this.color = Color.RED;
    }

}

enum Color {
    RED,GREEN,YELLOW;

枚舉類的構造方法必須是私有的。
帶參數構造方法的枚舉類：

enum Color{
    RED("red"),YELLOW("yellow"),GREEN("green");
    
    private Color(String name){
        
    }
}

枚舉的api的操作：查看jdk文檔
name():返回枚舉名
ordinal():枚舉下標，從0開始

靜態(tài)導入

可以在代碼里直接使用靜態(tài)導入方式，導入靜態(tài)方法或常量。
import static xx.xx.xx;

package cn.itcast.test2;

import static java.lang.System.out;

public class TestDemo4 {
    public static void main(String[] args){
        out.println("靜態(tài)導入靜態(tài)常量out");
    }
}

自動拆裝箱：

裝箱：把基本數據類型轉換為對應的包裝類
拆箱：把包裝類對象轉換成基本數據類型

package cn.itcast.test2;

public class TestDemo4 {
    public static void main(String[] args){
        //自動裝箱
        Integer i = 10;
        //自動拆箱
        int m = i;
    }
}

增強for循環(huán)：

語法：for(類型 遍歷變量 ：需要遍歷的集合){}

實現Iterable接口即可使用增強for循環(huán)
list，set實現了Iterable接口，可以使用增強for循環(huán)，map沒有實現，不能使用增強for循環(huán)

設計增強for循環(huán)的目的是為了替代迭代器，增強for循環(huán)的底層是用迭代器實現的。

可變參數

語法：例：public void function(int... nums){}，nums可以理解為一個存儲傳遞過來的參數的數組
注意：
調用是function()函數的參數只能寫在其參數列表中，不能單獨定義；
在一個方法的參數列表定義中只能有一個可變參數；
可變參數必須放在其他所有參數的后面，例如add(int a,int b,int... nums);

反射（********要理解********）：

反射應用在一些通用性比較高的代碼中。
大多數的框架都是使用反射來實現的（面試的時候會問框架底層的實現，涉及反射相關的知識）。

框架開發(fā)都是基于配置文件開發(fā)的：在配置文件中配置類，通過反射來得到類中的所有內容，或者執(zhí)行類中的某個方法。

類中的所有內容：屬性、無參構造方法、有參構造方法、普通方法

反射的原理：

1、把xxx.java文件保存到本地硬盤；
2、編譯.java文件成.class文件；
3、使用jvm，把.class文件通過類加載加載到內存中；
4、基于萬事萬物皆對象的原則，.class文件在內存中使用Class類表示；
5、當使用反射時，首先需要獲取到Class類，得到這個類之后，就可以得到.class文件里面的所有內容，包括屬性、構造函數、普通方法；屬性通過類Filed表示，構造方法通過類Constructor表示，普通方法通過類Method表示。

獲取Class類的三種方式：
package cn.itcast.test2;

import org.junit.Test;

public class TestDemo5 {

    public static void main(String[] args) throws Exception {
        //獲取Class類的三種方式
        Class clazz1 = Person.class;
        Class clazz2 = new Person().getClass();
        Class clazz3 = Class.forName("cn.itcast.test2.Person");
    }
}
使用反射來操作類中的構造方法：

Person.java文件內容：

package cn.itcast.test2;

public class Person {
    //屬性
    private String name;
    private String id;
    
    //無參構造函數
    public Person(){}
    
    //有參構造函數
    public Person(String name, String id){
        this.name = name;
        this.id = id;
    }
    
    //普通方法
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
}

TestDemo.java文件的內容：

package cn.itcast.test2;

import java.lang.reflect.Constructor;

import org.junit.Test;

public class TestDemo5 {

    public static void main(String[] args) throws Exception {
        //獲取Class類的三種方式
        Class clazz1 = Person.class;
        Class clazz2 = new Person().getClass();
        Class clazz3 = Class.forName("cn.itcast.test2.Person");
    }
    
    //操作無參數構造方法
    @Test
    public void TestConstructor1() throws Exception{
        //首先獲取Class
        Class clazz = Class.forName("cn.itcast.test2.Person");
        //使用無參構造方法獲取Person類的實例
        Person p = (Person) clazz.newInstance();
    }
    
    //操作有參數的構造方法
    @Test
    public void TestConstructor2() throws Exception{
        //首先獲取Class
        Class clazz = Class.forName("cn.itcast.test2.Person");
        //獲取傳遞有參數的構造方法，里面的參數類型使用class形式傳遞
        Constructor cs = clazz.getConstructor(String.class, String.class);
        //通過有參數的構造方法設置值
        Person p = (Person) cs.newInstance("LiSi", "100");
    }
}
使用反射來操作類中的屬性：

在TestDemo.java中添加如下函數：

    //操作屬性
    @Test
    public void TestAttribute() throws Exception{
        //得到Class類
        Class c2 = Class.forName("cn.itcast.test2.Person");
        //得到Person類實例
        Person p = (Person) c2.newInstance();
        
        //得到name屬性
        //Field[] fs = c2.getDeclaredFields();//表示得到所有的屬性集合
        Field f = c2.getDeclaredField("name");
        
        //設置可以操作私有屬性name
        f.setAccessible(true);
        
        //設置屬性值
        f.set(p, "WangWu");//相當于p.name = "WangWu"
    }
使用反射來操作類中的普通方法：
    //操作普通方法
    @Test
    public void TestCommon() throws Exception{
        //得到Class類
        Class c3 = Class.forName("cn.itcast.test2.Person");
        //得到Person實例
        Person p = (Person) c3.newInstance();
        //得到普通方法
        //c4.getDeclaredMethods();//得到所有的普通方法
        Method m1 = c3.getDeclaredMethod("setName", String.class);
        //讓setName方法執(zhí)行，設置name值
        m1.invoke(p, "NiuQi");
        System.out.println(p.getName());
    }

當操作的方法是靜態(tài)類的方法時，則不需要獲取類的實例，直接寫m1.invoke(null,"參數值");

上述內容對應的TestDemo.java文件的完整內容
package cn.itcast.test2;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import org.junit.Test;

public class TestDemo {

    public static void main(String[] args) throws Exception {
        //獲取Class類的三種方式
        Class clazz1 = Person.class;
        Class clazz2 = new Person().getClass();
        Class clazz3 = Class.forName("cn.itcast.test2.Person");
    }
    
    //操作無參數構造方法
    @Test
    public void TestConstructor1() throws Exception{
        //首先獲取Class
        Class clazz = Class.forName("cn.itcast.test2.Person");
        //使用無參構造方法獲取Person類的實例
        Person p = (Person) clazz.newInstance();
    }
    
    //操作有參數的構造方法
    @Test
    public void TestConstructor2() throws Exception{
        //首先獲取Class
        Class clazz = Class.forName("cn.itcast.test2.Person");
        //獲取傳遞有參數的構造方法，里面的參數類型使用class形式傳遞
        Constructor cs = clazz.getConstructor(String.class, String.class);
        //通過有參數的構造方法設置值
        Person p = (Person) cs.newInstance("LiSi", "100");
        
        System.out.println(p.getName());
    }
    
    //操作屬性
    @Test
    public void TestAttribute() throws Exception{
        //得到Class類
        Class c2 = Class.forName("cn.itcast.test2.Person");
        //得到Person類實例
        Person p = (Person) c2.newInstance();
        
        //得到name屬性
        //Field[] fs = c2.getDeclaredFields();//表示得到所有的屬性集合
        Field f = c2.getDeclaredField("name");
        
        //設置可以操作私有屬性name
        f.setAccessible(true);
        
        //設置屬性值
        f.set(p, "WangWu");//相當于p.name = "WangWu"
        
        System.out.println(p.getName());
    }
    
    //操作普通方法
    @Test
    public void TestCommon() throws Exception{
        //得到Class類
        Class c3 = Class.forName("cn.itcast.test2.Person");
        //得到Person實例
        Person p = (Person) c3.newInstance();
        //得到普通方法
        //c4.getDeclaredMethods();//得到所有的普通方法
        Method m1 = c3.getDeclaredMethod("setName", String.class);
        //讓setName方法執(zhí)行，設置name值
        m1.invoke(p, "NiuQi");
        System.out.println(p.getName());
    }
}
?著作權歸作者所有,轉載或內容合作請聯系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容