junit的使用單元測(cè)試
測(cè)試對(duì)象是一個(gè)類(lèi)的方法雪侥，junit不是javase的一部分碗殷，導(dǎo)入jar包，idea自動(dòng)已經(jīng)導(dǎo)入了速缨，junit版本：3.x锌妻；4.x 單元測(cè)試的時(shí)候，命名方法：public void 方法名(){}
- 使用注釋的方法運(yùn)行測(cè)試方法旬牲，在方法的上面寫(xiě)
@Test
package cn.itcast.test02;
public class TestJunit {
public void testAdd(int a,int b){
System.out.println(a+b);
}
public void tests11(){
System.out.println("test11>>>");
}
}
package cn.itcast.test02;
import org.junit.Test;
import static org.junit.Assert.*;
public class TestJunitTest {
@org.junit.Test
public void testAdd() {
TestJunit testJunit = new TestJunit();
testJunit.testAdd(2,3);
}
@Test
public void test11(){
TestJunit testJunit = new TestJunit();
testJunit.tests11();
}
}
快捷鍵：選中方法shift+command+T
執(zhí)行方法：右鍵>runas
當(dāng)出現(xiàn)?的時(shí)候方法通過(guò)
要運(yùn)行類(lèi)中的多個(gè)測(cè)試方法仿粹，點(diǎn)擊其中空白的位置右鍵>runas
ignore:表示不進(jìn)行單元測(cè)試
Before:在每個(gè)方法之前運(yùn)行
After:在每個(gè)方法之后運(yùn)行
斷言：
package cn.itcast.test02;
import org.junit.Assert;
import org.junit.Test;
public class TestJunitTest2 {
@Test
public void test02(){
int a = 3;
int b = 5;
int sum = a+b;
//使用斷言
//Assert.assertEquals("期望的值" + "方法實(shí)際運(yùn)行的值");
Assert.assertEquals(8,sum);
}
}
泛型類(lèi)
- 一般是用在集合上，把一個(gè)字符串類(lèi)型的值放進(jìn)集合后原茅，只能是object類(lèi)型吭历。要進(jìn)行類(lèi)型轉(zhuǎn)換可能出現(xiàn)類(lèi)型轉(zhuǎn)換錯(cuò)誤，解決這個(gè)問(wèn)題可以使用泛型類(lèi)
在集合上使用泛型
- 常用的集合：list set map
泛型的語(yǔ)法：集合<String >比如 list<String> -
在List上的使用
List的輸出三種方法
package cn.itcast.test02.TestList;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class testListTest {
@Test
public void testlist() {
List<String> list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//普通for循環(huán)
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
System.out.println("=========");
//增強(qiáng)foreach循環(huán)
for (String list1:list){
System.out.println(list1);
}
System.out.println("=========");
//迭代器
Iterator<String> iterable = list.iterator();
while (iterable.hasNext()){
System.out.println(iterable.next());
}
}
}
增強(qiáng)for循環(huán)的底層就是迭代器Iterator
-
在set上使用泛型
package cn.itcast.test02.Test泛型;
import org.junit.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestSet {
@Test
public void Testset(){
Set<String> set = new HashSet<String>();
set.add("www");
set.add("qqq");
set.add("zzz");
//有序的輸出擂橘，并且元素不能重復(fù)
//foreach遍歷
for (String s :
set) {
System.out.println(s);
}
//使用迭代器遍歷
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
在Map上使用泛型
package cn.itcast.test02.Test泛型;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class TestMap {
@Test
public void TestMap(){
Map<String,String> map = new HashMap<String, String>();
map.put("aaa","111");
map.put("bbb","222");
map.put("ccc","333");
//1.獲取所有的key晌区，通過(guò)key得到value 使用get方法
//2.獲取key和value的關(guān)系
Set<String> set = map.keySet();
//遍歷key返回set
for (String key:
set) {
String value = map.get(key);
System.out.println(key+" "+ value);
}
System.out.println("=========");
Set<Map.Entry<String, String>> set1 = map.entrySet();
for (Map.Entry<String,String> entry:
set1) {
//entry是key和value的關(guān)系
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+" "+ value);
}
}
}
- 在泛型里面寫(xiě)的應(yīng)該是一個(gè)對(duì)象，寫(xiě)基本數(shù)據(jù)類(lèi)型的對(duì)應(yīng)包裝類(lèi)
char -Character
int-Integer
泛型使用在方法上
- 定義一個(gè)數(shù)組通贞，實(shí)現(xiàn)指定位置上數(shù)組元素的交換
方法邏輯相同朗若，只是數(shù)據(jù)類(lèi)型不同，這個(gè)時(shí)候使用泛型的方法
package cn.itcast.test.TestShuZuJiaoHuan;
import java.util.Arrays;
public class Testdome {
public static void main(String[] args) {
//創(chuàng)建數(shù)組
//實(shí)現(xiàn)11 和 13 的交換
Integer[] arr1 = {10, 11, 12, 13, 14};
swap1(arr1, 1, 3);
System.out.println(Arrays.toString(arr1));
System.out.println("==========");
//創(chuàng)建一個(gè)String類(lèi)型的數(shù)組,實(shí)現(xiàn)bb和dd的交換
String[] arr2 = {"aa", "bb", "cc", "dd", "ff"};
swap1(arr2, 1, 3);
System.out.println(Arrays.toString(arr2));
}
/*使用泛型的方法定義L一個(gè)由大寫(xiě)字母表示T：這個(gè)T表示任意的類(lèi)型
* 寫(xiě)在返回值之前void之前
* 表示定義了一個(gè)類(lèi)型昌罩，這個(gè)類(lèi)型是T
* 下面就可以使用這個(gè)類(lèi)型T了
* */
public static <T> void swap1(T[] arr, int a, int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/*private static void swap1(int[] arr1, int i, int j) {
//定義一個(gè)中間變量
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
private static void swap1(String[] arr1, int i, int j) {
//定義一個(gè)中間變量
String temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}*/
}
泛型在類(lèi)上的使用
- 在一個(gè)類(lèi)上定義一個(gè)類(lèi)型捡偏，這個(gè)類(lèi)型可以在類(lèi)里面直接使用
package cn.itcast.test.Test泛型;
public class TestClass<T> {
//在類(lèi)里面直接使用T類(lèi)型
public void test1(T bb){
}
//寫(xiě)一個(gè)靜態(tài)方法 在類(lèi)上面定義的泛型，不能在靜態(tài)方法里面使用
public static <A> void test2(A cc){
}
}
枚舉類(lèi)
使用關(guān)鍵字enum
emum Color3{
RED,GREEN,YELLOW;
}
package cn.itcast.test.Test枚舉;
public class TestEnum1 {
//傳統(tǒng)方法
private int color;
//第二種方法
private Color2 color1;
//第三種方法峡迷，枚舉類(lèi)
private Color3 color3;
public void Test() {
this.color = 1000;//Color1.RED;
this.color1 = Color2.RED;
this.color3 = Color3.GREEN;
}
}
class Color1 {
public static final int RED = 1;
public static final int GREEN = 2;
public static final int YELLOW = 3;
}
class Color2 {
//構(gòu)造方法私有化
private Color2() {}
public static final Color2 RED = new Color2();
public static final Color2 GREEN = new Color2();
public static final Color2 YELLOW = new Color2();
}
enum Color3{
RED,GREEN,YELLOW;
}
枚舉的構(gòu)造方法是私有的
特殊枚舉的操作
在枚舉類(lèi)里面有構(gòu)造方法:構(gòu)造方法里面有參數(shù)需要在每個(gè)實(shí)例上都寫(xiě)參數(shù)银伟，在枚舉類(lèi)里面有抽象方法：在枚舉的每個(gè)實(shí)例中都重寫(xiě)這個(gè)抽象方法
package cn.itcast.test.Test枚舉;
public class TestEnum2 {
}
enum Color11{
RED("red"){
@Override
public void print1() {
System.out.println("red");
}
},GREEN("green") {
@Override
public void print1() {
System.out.println("green");
}
},YELLOW("yellow") {
@Override
public void print1() {
System.out.println("yellow");
}
};
private Color11(String name){}
//當(dāng)在枚舉里面實(shí)現(xiàn)抽象方法你虹，需要在每個(gè)實(shí)例上都實(shí)現(xiàn)抽象方法
public abstract void print1();
}
枚舉的api的操作
- name():返回枚舉的名稱(chēng)
ordinal():枚舉的下標(biāo)，下標(biāo)從0開(kāi)始
valueOf(Class<T> enumType,String name):得到枚舉對(duì)象 - 還有兩個(gè)自動(dòng)生成的方法
valueof(String name):轉(zhuǎn)換枚舉對(duì)象
values:獲得所有枚舉對(duì)象的數(shù)組
package cn.itcast.test.Test枚舉;
import org.junit.Test;
public class TestEnum3 {
//知道枚舉的對(duì)象彤避，得到枚舉名稱(chēng)和下標(biāo)
@Test
public void test1(){
//得到枚舉對(duì)象
Color100 color100 = Color100.RED;
//得到枚舉的名稱(chēng)
String name = color100.name();
//得到枚舉下標(biāo)
int ordinal = color100.ordinal();
System.out.println(name+" " + ordinal);
}
//知道枚舉的名稱(chēng)傅物，得到枚舉的對(duì)象和下標(biāo)
@Test
public void test2(){
String name1 = "GREEN";
//得到對(duì)象
Color100 color100 = Color100.valueOf(name1);
//得到下標(biāo)
int ordinal = color100.ordinal();
System.out.println(ordinal);
}
//知道枚舉的下標(biāo)，得到枚舉的對(duì)象和名稱(chēng)
@Test
public void test3(){
int idx2= 2;
Color100[] values = Color100.values();
//根據(jù)下標(biāo)得到對(duì)象
Color100 value = values[idx2];
//得到枚舉的名稱(chēng)
String name = value.name();
System.out.println(name);
}
}
enum Color100{
RED,GREEN,YELLOW;
}
靜態(tài)導(dǎo)入
- 可以在代碼里面直接使用靜態(tài)導(dǎo)入方法琉预，導(dǎo)入靜態(tài)方法或者常量
- import static xxx.xxx.xxx
package cn.itcast.test.test靜態(tài)導(dǎo)入;
import java.util.Arrays;
import static java.util.Arrays.sort;
import static java.lang.System.out;
import static java.util.Arrays.toString;
public class TestDemo1 {
public static void main(String[] args) {
out.println("hello");
int[] arr1 = {10,1,3,20,15};
sort(arr1);
//out.println(toString(arr1));出錯(cuò)董饰，因?yàn)閛bject里面也有toString方法
}
}
比如使用計(jì)算器的時(shí)候，可以導(dǎo)入Math方法圆米，可以不用寫(xiě)Math.
泛型的擦除
- 首先泛型是出現(xiàn)在源代碼當(dāng)中的卒暂，當(dāng)編譯之后泛型就不存在了
package cn.itcast.test.Test泛型;
import java.util.Arrays;
/**
* 實(shí)現(xiàn)一個(gè)泛型方法，接受任意類(lèi)型的數(shù)組娄帖，顛倒數(shù)組中的所有元素
*/
public class TestDiandao {
public static void main(String[] args){
Integer[] arr1 = {10,12,13,14,20};
System.out.println(Arrays.toString(arr1));
//寫(xiě)方法實(shí)現(xiàn)顛倒
reverses(arr1);
System.out.println(Arrays.toString(arr1));
String[] arr2 = {"a","bb","cc","dd","ff"};
System.out.println(Arrays.toString(arr2));
reverses(arr2);
System.out.println(Arrays.toString(arr2));
}
public static<T> void reverses(T[] arr1) {
/**
* 將第一個(gè)和最后一個(gè)元素交換位置
* 將倒數(shù)第二個(gè)和第二個(gè)交換位置
* 交換的次數(shù)是長(zhǎng)度除二
*/
for (int i = 0; i < arr1.length/2; i++) {
T temp = arr1[i];
arr1[i] = arr1[arr1.length-1-i];
arr1[arr1.length-i-1] = temp;
}
}
}
可變參數(shù)
可變參數(shù)可以應(yīng)用的場(chǎng)景：實(shí)現(xiàn)兩個(gè)數(shù)的相加也祠，實(shí)現(xiàn)三個(gè)數(shù)的相加，實(shí)現(xiàn)四個(gè)數(shù)的相加
如果實(shí)現(xiàn)的多個(gè)方法近速，這些方法里面的邏輯基本相同诈嘿，唯一不同的是傳遞的參數(shù)的個(gè)數(shù)，可以使用可變參數(shù)
package cn.itcast.test.Test可變參數(shù);
/**
* 演示可變參數(shù)
*/
public class TestDemo01 {
public static void main(String[] args) {
add1(10, 20);
add1(10, 20, 30);
add1(10, 20, 30, 40);
}
public static void add1(int... nums) {
//nums理解魏一個(gè)數(shù)組削葱，存儲(chǔ)傳遞過(guò)來(lái)的參數(shù)
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
System.out.println(sum);
}
/*//重載實(shí)現(xiàn)可變參數(shù)的相加
public void add1(int a, int b) {
int sum = a + b;
System.out.println(sum);
}
public void add1(int a, int b, int c) {
int sum = a + b + c;
System.out.println(sum);
}
public void add1(int a, int b, int c, int d) {
int sum = a + b + c + d;
System.out.println(sum);
}*/
}
定一個(gè)方法：數(shù)據(jù)類(lèi)型... 數(shù)組的名稱(chēng)
??：
- 可變參數(shù)需要寫(xiě)在方法的參數(shù)列表中奖亚，不能單獨(dú)定義
- 在參數(shù)列表中只能有一個(gè)可變列表
- 方法的參數(shù)列表中的可變參數(shù)，必須放在參數(shù)的最后add1(int a,int...nums)
