Java知識(shí)補(bǔ)漏

junit的使用單元測試

測試對(duì)象是一個(gè)類的方法，junit不是javase的一部分，導(dǎo)入jar包，idea自動(dòng)已經(jīng)導(dǎo)入了，junit版本：3.x；4.x 單元測試的時(shí)候，命名方法：public void 方法名(){}

  • 使用注釋的方法運(yùn)行測試方法，在方法的上面寫@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í)候方法通過
要運(yùn)行類中的多個(gè)測試方法，點(diǎn)擊其中空白的位置右鍵>runas
ignore:表示不進(jìn)行單元測試
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);
    }
}

泛型類

  • 一般是用在集合上，把一個(gè)字符串類型的值放進(jìn)集合后，只能是object類型。要進(jìn)行類型轉(zhuǎn)換可能出現(xiàn)類型轉(zhuǎn)換錯(cuò)誤，解決這個(gè)問題可以使用泛型類
    在集合上使用泛型
  • 常用的集合：list set map
    泛型的語法：集合<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，通過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);
        }
    }
}
  • 在泛型里面寫的應(yīng)該是一個(gè)對(duì)象，寫基本數(shù)據(jù)類型的對(duì)應(yīng)包裝類
    char -Character
    int-Integer

泛型使用在方法上

  • 定義一個(gè)數(shù)組，實(shí)現(xiàn)指定位置上數(shù)組元素的交換
    方法邏輯相同，只是數(shù)據(jù)類型不同，這個(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類型的數(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è)由大寫字母表示T：這個(gè)T表示任意的類型
     * 寫在返回值之前void之前
     * 表示定義了一個(gè)類型，這個(gè)類型是T
     * 下面就可以使用這個(gè)類型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;
    }*/
}

泛型在類上的使用

  • 在一個(gè)類上定義一個(gè)類型，這個(gè)類型可以在類里面直接使用
package cn.itcast.test.Test泛型;

public class TestClass<T> {
    //在類里面直接使用T類型
    public void test1(T bb){
        
    }
    //寫一個(gè)靜態(tài)方法 在類上面定義的泛型，不能在靜態(tài)方法里面使用
    public static <A> void test2(A cc){
        
    }
}

枚舉類

使用關(guān)鍵字enum
emum Color3{
RED,GREEN,YELLOW;
}

package cn.itcast.test.Test枚舉;

public class TestEnum1 {
    //傳統(tǒng)方法
    private int color;
    //第二種方法
    private Color2 color1;
    //第三種方法，枚舉類
    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)造方法是私有的

特殊枚舉的操作
在枚舉類里面有構(gòu)造方法:構(gòu)造方法里面有參數(shù)需要在每個(gè)實(shí)例上都寫參數(shù)，在枚舉類里面有抽象方法：在枚舉的每個(gè)實(shí)例中都重寫這個(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():返回枚舉的名稱
    ordinal():枚舉的下標(biāo)，下標(biāo)從0開始
    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ì)象，得到枚舉名稱和下標(biāo)
    @Test
    public void test1(){
        //得到枚舉對(duì)象
       Color100 color100 = Color100.RED;
        //得到枚舉的名稱
        String name = color100.name();
        //得到枚舉下標(biāo)
        int ordinal = color100.ordinal();
        System.out.println(name+" " + ordinal);
    }
    //知道枚舉的名稱，得到枚舉的對(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ì)象和名稱
    @Test
    public void test3(){
        int idx2= 2;
        Color100[] values = Color100.values();
        //根據(jù)下標(biāo)得到對(duì)象
        Color100 value = values[idx2];
        //得到枚舉的名稱
        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方法，可以不用寫Math.

泛型的擦除

  • 首先泛型是出現(xiàn)在源代碼當(dāng)中的，當(dāng)編譯之后泛型就不存在了
package cn.itcast.test.Test泛型;

import java.util.Arrays;

/**
 * 實(shí)現(xiàn)一個(gè)泛型方法，接受任意類型的數(shù)組，顛倒數(shù)組中的所有元素
 */
public class TestDiandao {
    public static void main(String[] args){
        Integer[] arr1 = {10,12,13,14,20};
        System.out.println(Arrays.toString(arr1));
        //寫方法實(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ù)是長度除二
         */
        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)用的場景：實(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ǔ)傳遞過來的參數(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ù)類型... 數(shù)組的名稱
??：

  1. 可變參數(shù)需要寫在方法的參數(shù)列表中，不能單獨(dú)定義
  2. 在參數(shù)列表中只能有一個(gè)可變列表
  3. 方法的參數(shù)列表中的可變參數(shù)，必須放在參數(shù)的最后add1(int a,int...nums)
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

推薦閱讀更多精彩內(nèi)容