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
泛型的语法：集合比如 list -
在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 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 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 set = new HashSet();
set.add("www");
set.add("qqq");
set.add("zzz");
//有序的输出，并且元素不能重复
//foreach遍历
for (String s :
set) {
System.out.println(s);
}
//使用迭代器遍历
Iterator 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 map = new HashMap();
map.put("aaa","111");
map.put("bbb","222");
map.put("ccc","333");
//1.获取所有的key，通过key得到value 使用get方法
//2.获取key和value的关系
Set set = map.keySet();
//遍历key返回set
for (String key:
set) {
String value = map.get(key);
System.out.println(key+" "+ value);
}
System.out.println("=========");
Set> set1 = map.entrySet();
for (Map.Entry 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 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类型
public void test1(T bb){
}
//写一个静态方法 在类上面定义的泛型，不能在静态方法里面使用
public static 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(ClassenumType,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 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);
}*/
}
定一个方法：数据类型... 数组的名称
⚠️：
- 可变参数需要写在方法的参数列表中，不能单独定义
- 在参数列表中只能有一个可变列表
- 方法的参数列表中的可变参数，必须放在参数的最后add1(int a,int...nums)