Java知识补漏

junit的使用单元测试

测试对象是一个类的方法，junit不是javase的一部分，导入jar包，idea自动已经导入了，junit版本：3.x；4.x 单元测试的时候，命名方法：public void 方法名(){}

  • 使用注释的方法运行测试方法，在方法的上面写@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
执行方法：右键>runas
当出现✅的时候方法通过
要运行类中的多个测试方法，点击其中空白的位置右键>runas
ignore:表示不进行单元测试
Before:在每个方法之前运行
After:在每个方法之后运行
断言：

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("期望的值" + "方法实际运行的值");
        Assert.assertEquals(8,sum);
    }
}

泛型类

  • 一般是用在集合上，把一个字符串类型的值放进集合后，只能是object类型。要进行类型转换可能出现类型转换错误，解决这个问题可以使用泛型类
    在集合上使用泛型
  • 常用的集合：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循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("=========");
        //增强foreach循环
        for (String list1:list){
            System.out.println(list1);
        }
        System.out.println("=========");
        //迭代器
        Iterator<String> iterable = list.iterator();
        while (iterable.hasNext()){
            System.out.println(iterable.next());
        }
    }
}

增强for循环的底层就是迭代器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");
        //有序的输出，并且元素不能重复
        //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的关系
        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的关系
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+" "+ value);
        }
    }
}
  • 在泛型里面写的应该是一个对象，写基本数据类型的对应包装类
    char -Character
    int-Integer

泛型使用在方法上

  • 定义一个数组，实现指定位置上数组元素的交换
    方法逻辑相同，只是数据类型不同，这个时候使用泛型的方法
package cn.itcast.test.TestShuZuJiaoHuan;

import java.util.Arrays;

public class Testdome {
    public static void main(String[] args) {
        //创建数组
        //实现11 和 13 的交换
        Integer[] arr1 = {10, 11, 12, 13, 14};
        swap1(arr1, 1, 3);
        System.out.println(Arrays.toString(arr1));
        System.out.println("==========");
        //创建一个String类型的数组,实现bb和dd的交换
        String[] arr2 = {"aa", "bb", "cc", "dd", "ff"};
        swap1(arr2, 1, 3);
        System.out.println(Arrays.toString(arr2));
    }

    /*使用泛型的方法定义L一个由大写字母表示T：这个T表示任意的类型
     * 写在返回值之前void之前
     * 表示定义了一个类型，这个类型是T
     * 下面就可以使用这个类型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) {
        //定义一个中间变量
        int temp = arr1[i];
        arr1[i] = arr1[j];
        arr1[j] = temp;
    }
    private static void swap1(String[] arr1, int i, int j) {
        //定义一个中间变量
        String temp = arr1[i];
        arr1[i] = arr1[j];
        arr1[j] = temp;
    }*/
}

泛型在类上的使用

  • 在一个类上定义一个类型，这个类型可以在类里面直接使用
package cn.itcast.test.Test泛型;

public class TestClass<T> {
    //在类里面直接使用T类型
    public void test1(T bb){
        
    }
    //写一个静态方法 在类上面定义的泛型，不能在静态方法里面使用
    public static <A> void test2(A cc){
        
    }
}

枚举类

使用关键字enum
emum Color3{
RED,GREEN,YELLOW;
}

package cn.itcast.test.Test枚举;

public class TestEnum1 {
    //传统方法
    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 {
    //构造方法私有化
    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;
}

枚举的构造方法是私有的

特殊枚举的操作
在枚举类里面有构造方法:构造方法里面有参数需要在每个实例上都写参数，在枚举类里面有抽象方法：在枚举的每个实例中都重写这个抽象方法

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){}
    //当在枚举里面实现抽象方法，需要在每个实例上都实现抽象方法
    public abstract void print1();
}

枚举的api的操作

  • name():返回枚举的名称
    ordinal():枚举的下标，下标从0开始
    valueOf(Class<T> enumType,String name):得到枚举对象
  • 还有两个自动生成的方法
    valueof(String name):转换枚举对象
    values:获得所有枚举对象的数组
package cn.itcast.test.Test枚举;

import org.junit.Test;

public class TestEnum3 {
    //知道枚举的对象，得到枚举名称和下标
    @Test
    public void test1(){
        //得到枚举对象
       Color100 color100 = Color100.RED;
        //得到枚举的名称
        String name = color100.name();
        //得到枚举下标
        int ordinal = color100.ordinal();
        System.out.println(name+" " + ordinal);
    }
    //知道枚举的名称，得到枚举的对象和下标
    @Test
    public void test2(){
        String name1 = "GREEN";
        //得到对象
        Color100 color100 = Color100.valueOf(name1);
        //得到下标
        int ordinal = color100.ordinal();
        System.out.println(ordinal);
    }
    //知道枚举的下标，得到枚举的对象和名称
    @Test
    public void test3(){
        int idx2= 2;
        Color100[] values = Color100.values();
        //根据下标得到对象
        Color100 value = values[idx2];
        //得到枚举的名称
        String name = value.name();
        System.out.println(name);
    }
}
enum Color100{
    RED,GREEN,YELLOW;
}

静态导入

  • 可以在代码里面直接使用静态导入方法，导入静态方法或者常量
  • import static xxx.xxx.xxx
package cn.itcast.test.test静态导入;

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));出错，因为object里面也有toString方法
    }
}

比如使用计算器的时候，可以导入Math方法，可以不用写Math.

泛型的擦除

  • 首先泛型是出现在源代码当中的，当编译之后泛型就不存在了
package cn.itcast.test.Test泛型;

import java.util.Arrays;

/**
 * 实现一个泛型方法，接受任意类型的数组，颠倒数组中的所有元素
 */
public class TestDiandao {
    public static void main(String[] args){
        Integer[] arr1 = {10,12,13,14,20};
        System.out.println(Arrays.toString(arr1));
        //写方法实现颠倒
        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) {
        /**
         *  将第一个和最后一个元素交换位置
         *  将倒数第二个和第二个交换位置
         *  交换的次数是长度除二
         */
        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;

        }
    }
}

可变参数

可变参数可以应用的场景：实现两个数的相加，实现三个数的相加，实现四个数的相加
如果实现的多个方法，这些方法里面的逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数

package cn.itcast.test.Test可变参数;

/**
 * 演示可变参数
 */
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理解魏一个数组，存储传递过来的参数
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
    /*//重载实现可变参数的相加
    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);
    }*/
}

定一个方法：数据类型... 数组的名称
⚠️：

  1. 可变参数需要写在方法的参数列表中，不能单独定义
  2. 在参数列表中只能有一个可变列表
  3. 方法的参数列表中的可变参数，必须放在参数的最后add1(int a,int...nums)
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,222评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,455评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,720评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,568评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,696评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,879评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,028评论 3赞 409
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,773评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,220评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,550评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,697评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,360评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,002评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,782评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,010评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,433评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,587评论 2赞 350

推荐阅读更多精彩内容