美文网首页
Java知识补漏

Java知识补漏

作者: 十六只猴子王 | 来源:发表于2019-04-20 21:47 被阅读0次

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)

相关文章

  • Java知识补漏

    junit的使用单元测试 测试对象是一个类的方法，junit不是javase的一部分，导入jar包，idea自动已...

  • Java基础知识——查缺补漏

    疯狂Java摘要 1.语言零碎基础知识 <1>.Windows中系统变量有系统变量和用户变量之分，就是作用域大小的...

  • 数值分析 知识补漏

    1、方程组（高斯消元，LU分解，AP=LU分解，误差问题，共轭梯度） 2、最小二乘（模型，正规方程，不相容，QR分...

  • java补漏-spi机制

    SPI的全名为Service Provider Interface.大多数开发人员可能不熟悉，因为这个是针对厂商或...

  • Stata--多重补漏mipolate

    mipolate多重补漏的命令，可用最邻近补漏，线性补漏、高次项补漏等方式进行补漏。

  • 线性代数知识补漏

    线性代数已经学习完毕基础部分了，下面就是矩阵分析了

  • jQuery 知识点补漏

    对象与数组的转换 http://www.cnblogs.com/lijuntao/p/6604276.html 遍...

  • 区块链革命

    这本书其实是知识点补漏书，帮助你理解什么是区块链，他是怎么回事，怎么玩的？以下是我“补漏”的节选，有摘录有个人理解...

  • PMP 2018-12-03

    最后1周了 要回顾知识点 查缺补漏了 闭关修炼 希望大家都能考过

  • Android内存溢出到性能优化

    写这个一方面当作对自己的知识点的查缺补漏，一方面也权当是学习笔记吧，以前也没想过系统地去了解这些。 从Java的内...

网友评论

      本文标题：Java知识补漏

      本文链接：https://www.haomeiwen.com/subject/nkqxgqtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Java知识补漏|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！