超详细的JUnit单元测试介绍

news2024/9/20 14:50:59

前言

在这里插入图片描述

本文为JUnit单元测试相关知识，下边将对JUnit单元测试概念，JUnit优点，JUnit安装与使用，JUnit运行流程与常用注解，JUnit测试套件使用及参数化设置，JUnit断言等进行详尽介绍~

📌博主主页：´Code_Wang的主页
👉Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
👉算法刷题路线可参考：算法刷题路线总结与相关资料分享，内含最详尽的算法刷题路线指南及相关资料分享~

目录

JUnit单元测试

  • 前言
  • 目录
  • 一、JUnit单元测试
    • 1️⃣什么是JUnit
    • 2️⃣JUnit优点
    • 3️⃣为什么要用JUnit
    • 4️⃣JUnit安装
    • 5️⃣简单例子快速入门
    • 6️⃣JUnit使用注意点及测试失败的两种情况
    • 7️⃣运行流程及常用注解
    • 8️⃣JUnit测试套件使用及参数化设置
  • 二、JUnit断言
    • 1️⃣断言概述
    • 2️⃣断言方法
    • 3️⃣测试代码
  • 后记

在这里插入图片描述

一、JUnit单元测试

​单元测试又称模块测试，属于白盒测试，是开发者编写的一小段代码，用于检验被测代码的一个很小的、很明确的功能是否正确。通常而言，一个单元测试是用于判断某个特定条件（或者场景）下某个特定函数的行为。

1️⃣什么是JUnit

  • JUnit是用于编写可复用测试集的简单框架，是xUnit的一个子集。xUnit是一套基于测试驱动开发的测试框架，有PythonUnit、CppUnit、JUnit等。
  • JUnit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。
  • 多数Java的开发环境都已经集成了JUnit作为单元测试的工具，比如IDEA，Eclipse等等。

2️⃣JUnit优点

另外JUnit是在极限编程和重构（refactor）中被极力推荐使用的工具，因为在实现自动单元测试的情况下可以大大的提高开发的效率，但是实际上编写测试代码也是需要耗费很多的时间和精力的，那么使用这个东西好处到底在哪里呢？

极限编程：
要求在编写代码之前先写测试，这样可以强制你在写代码之前好好的思考代码（方法）的功能和逻辑，否则编写的代码很不稳定，那么你需要同时维护测试代码和实际代码，这个工作量就会大大增加。因此在极限编程中，基本过程是这样的：构思－> 编写测试代码－> 编写代码－> 测试，而且编写测试和编写代码都是增量式的，写一点测一点，在编写以后的代码中如果发现问题可以较快的追踪到问题的原因，减小回归错误的纠错难度。

重构：
其好处和极限编程中是类似的，因为重构也是要求改一点测一点，减少回归错误造成的时间消耗。

其他情况：
我们在开发的时候使用JUnit写一些适当的测试也是有必要的，因为一般我们也是需要编写测试的代码的，可能原来不是使用的JUnit，如果使用JUnit，而且针对接口（方法）编写测试代码会减少以后的维护工作，例如以后对方法内部的修改（这个就是相当于重构的工作了）。另外就是因为JUnit有断言功能，如果测试结果不通过会告诉我们哪个测试不通过，为什么，而如果是像以前的一般做法是写一些测试代码看其输出结果，然后再由自己来判断结果是否正确，使用JUnit的好处就是这个结果是否正确的判断是它来完成的，我们只需要看看它告诉我们结果是否正确就可以了，在一般情况下会大大提高效率。

3️⃣为什么要用JUnit

  • 测试框架可以帮助我们对编写的程序进行有目的地测试，帮助我们最大限度地避免代码中的bug，以保证系统的正确性和稳定性。
  • 很多人对自己写的代码，测试时就简单写main，然后sysout输出控制台观察结果。这样非常枯燥繁琐，不规范。缺点：测试方法不能一起运行，测试结果要程序猿自己观察才可以判断程序逻辑是否正确。JUnit的断言机制，可以直接将我们的预期结果和程序运行的结果进行一个比对，确保对结果的可预知性。

断言概述:

  • 编写代码时,我们总是会做出一些假设,断言就是用于在代码中捕捉这些假设。
  • 可以将断言看作是异常处理的一种高级形式。
  • 断言表示为一些布尔表达式,程序员相信在程序中的某个特定点该表达式值为真。

4️⃣JUnit安装

  • JUnit官网：http://JUnit.org/
  • JUnit的jar包下载：https://github.com/JUnit-team/JUnit/wiki/Download-and-Install
  • 如果你安装的开发工具是eclipse，这就很好办，因为eclipse自带JUnit，只是不同版本的eclipse把JUnit放在了不同的地方，但是也很好找。
  • 如果你安装的开发工具是IDEA，那么要么去下载jar包，要么通过IDEA去安装插件

IDEA中JUnit安装步骤如下：
（1）新建一个项目工程，点击 文件File - 新建New - 项目Project，我这里项目名使用 JunitProj，点击完成
在这里插入图片描述
（2）完成项目的创建后，点击 文件File-设置Settings-Plugins 在搜索栏搜索 JUnit，此时出现了几个Plugins，选择 JUnit。Install JetBrains plugin…和Browser repositories两种方法，前者直接点击下载就好；解决IDEA 的 plugins 搜不到任何的插件问题：https://www.jb51.net/article/185940.htm
在这里插入图片描述
（3）安装完成之后，需要重启IDEA;
在这里插入图片描述
（4）当你下载好Junit4插件后,打开 文件File-设置Settings，如图注明修改配置
在这里插入图片描述
（5）在 JUnit4 模块里找到此代码 将test去掉
在这里插入图片描述

5️⃣简单例子快速入门

以前测试自己写的代码都是新建一个main方法，然后sysout输出控制台观察结果，繁琐又麻烦！现在让我们开始JUnit单元测试之旅！

（1）创建简单业务类
编写一个简单的计算类：Calculate类

package demo.util;

/**
 * 实现加减乘除的简单计算类
 */
public class Calculate {
	public int add(int a, int b) {
		return a + b;
	}
	public int subtract(int a, int b) {
		return a - b;
	}
	public int multiply(int a, int b) {
		return a * b;
	}
	public int divide(int a, int b) {
		return a / b;
	}
}

（2）创建测试类

  • 1、在项目目录创建一个文件，用于保存我们的测试代码，创建文件夹test、然后将他设置为测试目录。
    在这里插入图片描述
  • 2、创建Junit4的测试代码，有两种方法（超级简单方便）

​第一种直接点击被测试类Calculator 使用 Ctrl+Shift+T
在这里插入图片描述
​第二种方法 鼠标右键点击类名 使用 goto-Test即可实现
在这里插入图片描述

  • 3、创建测试，根据自身需要来勾选
    在这里插入图片描述

（3）修改生成的测试类代码

上面步骤生成的测试类只包含测试方法的模板，并没有具体的测试细节，修改成如下：（其中有比较多的重复代码，暂时不管；并将减法的测试设为有问题）

package demo.util;
import org.junit.Assert;
import org.junit.Test;

class CalculateTest {
    Calculate Calculate;
    @Test
    public void testAdd() {
        calculate = new Calculate();
        int result = calculate.add(2, 3);
        Assert.assertEquals("加法有问题", 5, result);
        /*
         * "加法有问题"：期望值和实际值不一致时，显示的信息
         * 5 ：期望值
         * result ：实际值
         * Assert 断言	assertEquals相等断言
         */
    }
    @Test
    public void testSubtract() {
        calculate = new Calculate();
        int result = calculate.subtract(12, 2);
        Assert.assertEquals("减法有问题", 10000, result); //故意设置减法期望值为10000
    }
    @Test
    public void testMultiply() {
        calculate = new Calculate();
        int result = calculate.multiply(2, 3);
        Assert.assertEquals("乘法有问题", 6, result);
    }
    @Test
    public void testDivide() {
        calculate = new Calculate();
        int result = calculate.divide(6, 3);
        Assert.assertEquals("除法有问题", 2, result);
    }
}

（4）运行结果

我们可以通过Run ->Edit Configuration或工具栏上的标签来调整我们测试运行配置：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
总共有4个测试方法，运行了4个方法；其中failed有1个，即有一个方法的输出结果跟我们的预期不一样。

6️⃣JUnit使用注意点及测试失败的两种情况

（1）JUnit使用的最佳实践

  • 1、测试方法上必须使用@Test进行修饰 (只有添加@Test,才是测试方法,测试的时候才会运行)
  • 2、测试方法必须使用public void 进行修饰，不能带任何的参数
  • 3、新建一个测试代码目录来存放我们的测试代码，即将测试代码和项目业务代码分开(不要在src下放测试代码)
  • 4、测试类所在的包名应该和被测试类所在的包名保持一致
  • 5、测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖
  • 6、测试类使用Test作为类名的后缀（不是必须）
  • 7、测试方法使用test作为方法名的前缀（不是必须）

（2）测试失败的两种情况

注意： 测试用例是用来达到测试想要的预期结果，而不能测试出程序的逻辑错误。
比如：你需要写一个计算长方形面积的方法，而你错误地认为周长的公式就是计算面积的。所以在测试方法中，就算结果达到了你的预期，但这显然不是正确的计算面积方法。

  • 新建测试类
package demo.util;
import org.junit.Assert;
import org.junit.Test;

public class ErrorAndFailureTest {
	@Test
	public void testAdd() {
		int result = new Calculate().add(3, 3);
		Assert.assertEquals("加法有问题", 5, result); // 预期值与程序输出不一样
	}
	@Test
	public void testDivide() {
		int result = new Calculate().divide(6, 0); // 除法中，除数为0
		Assert.assertEquals("除法有问题", 3, result);
	}
}
  • 运行结果

testAdd()方法是failure(失败/故障)错误
在这里插入图片描述
testDivide()方法是error错误
在这里插入图片描述
说明:

  • Failure一般由单元测试使用的断言方法判断失败所引起的，这经表示测试点发现了问题，就是说程序输出的结果和我们预期的不一样。
  • Error是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中的一个隐藏的bug。

7️⃣运行流程及常用注解

（1）JUnit的运行流程

  • 新建测试类

右键被测试类，新建一个测试类。弹出框中，首先改变测试类所在的代码目录，然后勾选4个方法：
在这里插入图片描述

  • 修改测试类代码
package demo.util;
import org.junit.*;

public class CalculateTest {
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("this is setUpBeforeClass()...");
    }
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("this is tearDownAfterClass()...");
    }
    @Before
    public void setUp() throws Exception {
        System.out.println("this is setUp() @Before");
    }
    @After
    public void tearDown() throws Exception {
        System.out.println("this is tearDown() @After");
    }
    @Test
    public void add() {
        System.out.println("this is add()");
    }
    @Test
    public void subtract() {
        System.out.println("this is subtract()");
    }
    @Test
    public void multiply() {
        System.out.println("this is multiply()");
    }
    @Test
    public void divide() {
        System.out.println("this is divide()");
    }
}

控制台输出如下：

this is setUpBeforeClass()...
this is setUp() @Before
this is subtract()
this is tearDown() @After
this is setUp() @Before
this is divide()
this is tearDown() @After
this is setUp() @Before
this is add()
this is tearDown() @After
this is setUp() @Before
this is multiply()
this is tearDown() @After
this is tearDownAfterClass()...
  • 总结说明

@BeforeClass修饰的方法会在所有方法被调用前被执行，而且该方法是静态的，所以当测试类被加载后接着就会运行它，而且在内存中它只会存在一份实例，它比较适合加载配置文件，进行初始化等等；
@AfterClass所修饰的方法会在所有方法被调用后被执行，通常用来对资源的清理，如关闭数据库的连接；
@Before和@After会在每个测试方法的前后各执行一次。

（2）JUnit常用注解

  • @Test:将一个普通的方法修饰成为一个测试方法 @Test(expected=XX.class)
  • @Test(expected=ArithmeticException.class)检查被测方法是否抛出ArithmeticException异
  • @Test(timeout=毫秒)
  • @BeforeClass：它会在所有的方法运行前被执行，static修饰，只执行一次
  • @AfterClass:它会在所有的方法运行结束后被执行，static修饰，只执行一次
  • @Before：会在每一个测试方法被运行前执行一次
  • @After：会在每一个测试方法运行后被执行一次
  • @Ignore:所修饰的测试方法会被测试运行器忽略
  • @RunWith:可以更改测试运行器 org.junit.runner.Runner
  • 一个JUnit4的单元测试用例执行顺序为： @BeforeClass -> @Before -> @Test -> @After -> @AfterClass;
  • 每一个测试方法的调用顺序为： @Before -> @Test -> @After;

JUnit4和JUnit5对比:

特性Junit 4Junit 5
在当前类的所有测试方法之前执行。注解在静态方法上。此方法可以包含一些初始化代码。@BeforeClass@BeforeAll
在当前类中的所有测试方法之后执行。注解在静态方法上。此方法可以包含一些清理代码。@AfterClass@AfterAll
在每个测试方法之前执行。注解在非静态方法上。可以重新初始化测试方法所需要使用的类的某些属性。@Before@BeforeEach
在每个测试方法之后执行。注解在非静态方法上。可以回滚测试方法引起的数据库修改。@After@AfterEach

@Test、@Ignore的测试

package demo.util;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

public class AnotationTest {
	@Test(expected = ArithmeticException.class)
	public void testDivide() {
		Assert.assertEquals("除法有问题", 3, new Calculate().divide(6, 0)); // 将除数设置为0
	}
	@Test(timeout = 2000)
	public void testWhile() {
		while (true) {
			System.out.println("run forever..."); // 一个死循环
		}
	}
	@Test(timeout = 3000)
	public void testReadFile() {
		try {
			Thread.sleep(2000); // 模拟读文件操作
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	@Ignore("...")
	@Test
	public void testIgnore() {
		System.out.println("会运行吗？");
	}
}

在这里插入图片描述
说明：

  • 1、testDivide()方法中，将除数设为0，本会抛出Error，但设置了@Test(expected=ArithmeticException.class)，说明我们预期它会抛出一个算术异常，所以程序结果也符合我们的预期。
  • 2、testWhile()方法是一个死循环，但设置了@Test(timeout=2000)，即2秒之后，自动结束循环。
  • 3、testReadFile()方法模拟读取文件操作，设置读取超时时间为3秒，等于或大于测试时间则认为不成功，而程序睡眠了2秒，没有超时。这里表示用作一些性能的测试。
  • 4、testIgnore()方法，因为使用的@Ignore注解，所以不会运行。

8️⃣JUnit测试套件使用及参数化设置

@RunWith： 当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器。

（1）JUnit测试套件
如果在测试类不增加的情况下，如何运行所有的单元测试代码类？一个个测试类的执行吗？显然繁琐且费劲。
将要运行的测试类集成在我们的测试套件中，比如一个系统功能对应一个测试套件，一个测试套件中包含多个测试类，每次测试系统功能时，只要执行一次测试套件就可以了。

  • 测试类及测试套件代码

新建3个测试任务类：

package demo.util;
import org.junit.Test;
public class TaskTest1 {
	@Test
	public void test() {
		System.out.println("this is TaskTest1...");
	} 
}
 
package demo.util;
import org.junit.Test;
public class TaskTest2 {
	@Test
	public void test() {
		System.out.println("this is TaskTest2...");
	}
} 
 
package demo.util;
import org.junit.Test;
public class TaskTest3 {
	@Test
	public void test() {
		System.out.println("this is TaskTest3...");
	}
}

新建一个套件类，包含以上三个任务类：

package demo.util;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
 
@RunWith(Suite.class)
@Suite.SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class})
public class SuiteTest {
	/*
	 * 1.测试套件就是组织测试类一起运行的
	 * 
	 * 写一个作为测试套件的入口类，这个类里不包含其他的方法
	 * 更改测试运行器Suite.class
	 * 将要测试的类作为数组传入到Suite.SuiteClasses({})
	 */
}

运行结果：
在这里插入图片描述

  • 说明

1、使用@RunWith注解，修改测试运行器。例如@RunWith(Suite.class)，这个类就成为测试套件的入口类。
2、@Suite.SuiteClasses()中放入测试套件的测试类，以数组的形式{class1,class2,…}作为参数

（2）JUnit参数化设置
如果测试代码大同小异，代码结构都是相同的，不同的只是测试的数据和预期值，那么有没有更好的办法将相同的代码结构提取出来，提高代码的重用度呢？
解决：进行参数化测试。

步骤：

  • 1、要进行参数化测试，需要在类上面指定如下的运行器：@RunWith (Parameterized.class)
  • 2、然后，在提供数据的方法上加上一个@Parameters注解，这个方法必须是静态static的，并且返回一个集合Collection。
  • 3、在测试类的构造方法中为各个参数赋值，（构造方法是由JUnit调用的），最后编写测试类，它会根据参数的组数来运行测试多次。

代码如下：

package demo.util;

import org.junit.Assert;

import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class) // 1.更改默认的测试运行器为RunWith(Parameterized.class)
public class ParameterTest {

	// 2.声明变量存放预期值和测试数据
	int expected = 0;
	int input1 = 0;
	int input2 = 0;

	// 3.声明一个返回值 为Collection的公共静态方法，并使用@Parameters进行修饰
	@Parameters
	public static Collection<Object[]> data() {
		return Arrays.asList(new Object[][] { { 3, 1, 2 }, { 4, 2, 2 } });
	}

	// 4.为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值
	public ParameterTest(int expected, int input1, int input2) {
		this.expected = expected;
		this.input1 = input1;
		this.input2 = input2;
	}

	// 5.运行测试方法，即可完成对多组数据的测试
	@Test
	public void testAdd() {
		Assert.assertEquals(expected, new Calculate().add(input1, input2));
	}

}

运行结果：
在这里插入图片描述

二、JUnit断言

1️⃣断言概述

断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。
使用断言可以创建更稳定、品质更好且 不易于出错的代码。当需要在一个值为FALSE时中断当前操作的话，可以使用断言。单元测试必须使用断言（Junit/JunitX）。
断言More:https://www.cnblogs.com/qiumingcheng/p/9506201.html

2️⃣断言方法

这个类提供了很多有用的断言方法来编写测试用例。只有失败的断言才会被记录。Assert 类中的一些有用的方法列式如下：

MethodDescription
assertNull(java.lang.Object object)检查对象是否为空
assertNotNull(java.lang.Object object)检查对象是否不为空
assertEquals(long expected, long actual)检查long类型的值是否相等
assertEquals(double expected, double actual, double delta)检查指定精度的double值是否相等
assertFalse(boolean condition)检查条件是否为假
assertTrue(boolean condition)检查条件是否为真
assertSame(java.lang.Object expected, java.lang.Object actual)检查两个对象引用是否引用同一对象（即对象是否相等）
assertNotSame(java.lang.Object unexpected, java.lang.Object actual)检查两个对象引用是否不引用同一对象(即对象不等)

3️⃣测试代码

package demo.util;
import org.junit.Test;
import static org.junit.Assert.*;

public class TestAssertions {
   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
      int val1 = 5;
      int val2 = 6;
      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

后记

在这里插入图片描述
👉Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
👉算法刷题路线可参考：算法刷题路线总结与相关资料分享，内含最详尽的算法刷题路线指南及相关资料分享~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2238.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

大数据Hadoop之——Apache Hudi 与 Presto/Trino集成

大数据Hadoop之——Apache Hudi 与 Presto/Trino集成

文章目录一、概述二、Trino 环境部署1&#xff09;安装JDK2&#xff09;安装python3&#xff09;安装Trino1、下载解压并配置环境变量2、修改配置3、启动服务4、测试验证三、在Hive中创建表关联Hudi表1&#xff09;添加jar包2&#xff09;创建库表关联Hudi四、Hudi 与 Trino集成…
阅读更多...
SpringCloud Alibaba系列 Sentinel（三）

SpringCloud Alibaba系列 Sentinel（三）

高并发下的微服务容错方案&#xff1f; 限流、熔断、降级 1&#xff1a;限流 在高并发系统中一定要用&#xff0c;高并发的所有请求进来&#xff0c;不是让每个请求都打到后台集群的&#xff0c;后台集群有它的消费能力&#xff0c;应该在它消费能力之内放行请求&#xff0c;…
阅读更多...
Hadoop HA集群全是standBy解决办法

Hadoop HA集群全是standBy解决办法

文章目录原理解决方案原理 hadoop集群配置HA后&#xff0c;会存在多个namenode&#xff0c;但是同一时间仅有一台NN为Active的状态&#xff0c;其他NN都是StandBy的状态。 上图是hadoop集群配置HA的原理图&#xff0c;从上图我们可以看到多个NN的状态切换&#xff0c;是依靠Z…
阅读更多...
linux命令与makefile学习

linux命令与makefile学习

linux命令与makefile学习文件权限通配符*常用命令makefilegcc与g区别&#xff1a;Linux上有一句话&#xff1a;一切皆文件 普通文件 “-” 目录文件 “d” &#xff08;directory&#xff09; 管道文件 “p” &#xff08;piping&#xff09; 链接文件“l” &#xff08;li…
阅读更多...
SAP FICO银行账户余额查询表开发说明书（包括开发源代码、测试样例及FS)

SAP FICO银行账户余额查询表开发说明书（包括开发源代码、测试样例及FS)

程序说明 满足财务银行账户余额查询明细的需求； 支持财务实时查看银行余额数据。 筛选界面 序号 栏位标题 字段类型 是否必须 是否为范围
阅读更多...
【pwn】2022 祥云杯 部分wp

【pwn】2022 祥云杯 部分wp

【pwn】2022 祥云杯 部分wp 前言 又是一年的祥云杯&#xff0c;相比去年我啥也不会写&#xff0c;今年起码写了几个签到… 又被队友带飞咯 protool Google的Protobuf&#xff0c;参考学习连接 https://bbs.pediy.com/thread-270004.htm 发现了栈溢出&#xff0c;protobuf…
阅读更多...
Unity技术手册-UGUI零基础详细教程-Toggle切换

Unity技术手册-UGUI零基础详细教程-Toggle切换

往期文章分享点击跳转>《导航贴》- Unity手册&#xff0c;系统实战学习点击跳转>《导航贴》- Android手册&#xff0c;重温移动开发 本文约3千字&#xff0c;新手阅读需要7分钟&#xff0c;复习需要2分钟 【收藏随时查阅不再迷路】 &#x1f449;关于作者 众所周知&#…
阅读更多...
2.6 Python 基本数据类型

2.6 Python 基本数据类型

1. 数据类型 类型是变量所指的内存中对象的类型. 内置的type()函数可以用来查询变量所指的对象类型。Python 3中有六个标准的数据类型: Numbers(数字), String(字符串), List(列表), Tuple(元组), Sets(集合), Dictionary(字典).2. Numbers 数字型 Python 有三种数字类型 in…
阅读更多...
SpringMVC基本配置

SpringMVC基本配置

小常规 springmvc的处理器对应的bean必须按照规范格式开发&#xff0c;为避免加入无效的bean可通过bean加载过滤器进行包含设定或排除设定&#xff0c;表现层bean标注通常设定为Controller在此发现图片没有加载出来回到程序去分析当发起一个请求以后DispatcherServlet配置拦截所…
阅读更多...
【JVM技术专题】 深入分析class字节码指令方法调用详解「原理篇」

【JVM技术专题】 深入分析class字节码指令方法调用详解「原理篇」

方法调用详解 ​ 调用目标在程序代码写好、编译器进行编译时就必须确定下来&#xff0c;这类方法的调用称为解析。 解析 ​ 在Java语言中符合**“编译期可知&#xff0c;运行期不可变”**这个要求的方法&#xff0c;主要包括静态方法和私有方法两大类&#xff0c;前者与类型…
阅读更多...
【JavaScript】网页轮播图

【JavaScript】网页轮播图

目录HTML搭建功能实现小圆圈事件左右按钮事件自动播放轮播图也叫焦点图&#xff0c;是网页中比较常见的网页特效。功能&#xff1a;鼠标经过轮播图模块&#xff0c;左右按钮显示&#xff0c;离开隐藏左右按钮。点击右侧按钮一次&#xff0c;图片往左播放一张&#xff0c;以此类…
阅读更多...
UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation代码补充

UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation代码补充

上一篇看了文章创新点的代码&#xff0c;现在看一下train文件等其余的文件。 看主函数&#xff1a; import os import torch import argparse import tqdm import sysimport cv2 import torch.nn as nn import torch.distributed as distfrom torch.optim import Adam, SGD fr…
阅读更多...
CVE-2022-21907 Microsoft Windows HTTP 协议栈远程代码执行漏洞复现

CVE-2022-21907 Microsoft Windows HTTP 协议栈远程代码执行漏洞复现

目录 0x01 声明&#xff1a; 0x02 简介&#xff1a; 0x03 漏洞概述&#xff1a; 0x04 影响版本&#xff1a; 0x05 环境搭建&#xff1a; 下载&#xff1a; 开启IIS&#xff1a; 0x06 漏洞复现&#xff1a; 利用POC&#xff1a; 0x07 流量分析&#xff1a; 客户端&am…
阅读更多...
算法提升 （三）基础数据结构

算法提升 （三）基础数据结构

作者&#xff1a;小萌新 专栏&#xff1a;算法提升 作者简介&#xff1a;大二学生 希望能够和大家一起进步&#xff01; 内容简介&#xff1a;简单介绍基本数据结构的简单面试题 不负韶华 链表 阅读这篇文章之前需要有初阶数据结构的基础 关于链表的结构如果还有不了解的同学…
阅读更多...
智能AI创意图片编辑Luminar Neo

智能AI创意图片编辑Luminar Neo

Luminar Neo是Mac上的智能AI技术编辑软件背景替换、图像层、除尘、重新照明选项等&#xff0c;从而实现精确掌控。同时在这款软件中还拥有可简化复杂的编辑程序&#xff0c;如此一来用户即可将自己大脑中想象的愿景变为现实&#xff0c;让使用者能有多大胆的想法都可以在这款软…
阅读更多...
深度学习 卷积神经网络原理

深度学习 卷积神经网络原理

深度学习 卷积神经网络原理一、前言二、全连接层的局限性三、卷积层3.1 如何进行卷积运算&#xff1f;3.2 偏置3.3 填充3.4 步长3.5 卷积运算是如何保留图片特征的&#xff1f;3.6 三维卷积3.7 多种特征提取四、池化层五、全连接层六、参考资料一、前言 本文分析了全连接层存在…
阅读更多...
burpsuite利用sql注入漏洞猜解数据库名称

burpsuite利用sql注入漏洞猜解数据库名称

目录 一、前提条件 二、burpsuite猜解数据库名 &#xff08;一&#xff09;设置firefox代理 &#xff08;二&#xff09;使用burpsuite的proxy模块截取数据包 &#xff08;三&#xff09;将proxy截取的数据包右击发送到intruder模块 &#xff08;四&#xff09;设置2个变量…
阅读更多...
【Spring】快速入门Spring框架

【Spring】快速入门Spring框架

文章目录1. 对Spring的理解2. Spring IoC3. DI4. 如何创建一个Spring项目4.1 创建一个Maven项目4.2 添加Spring框架支持4.3 添加启动类5. 存储Bean对象5.1 添加配置文件5.2 创建Bean对象5.3 注册Bean6. 获取并使用Bean对象7. 更简单存储Bean对象的方式7.1 前置工作7.2 添加存储…
阅读更多...
python爬虫1

python爬虫1

1.1　网络爬虫概述 网络爬虫&#xff08;又被称为网络蜘蛛、网络机器人&#xff0c;在某社区中经常被称为网页追逐者&#xff09;&#xff0c;可以按照指定的规则&#xff08;网络爬虫的算法&#xff09;自动浏览或抓取网络中的信息&#xff0c;通过 Python 可以很轻松地编写爬…
阅读更多...
二叉搜索树+二叉进阶oj

二叉搜索树+二叉进阶oj

索引二叉搜索树1.二叉搜索树概念与性能分析2.二叉树的应用3.二叉树的实现细节4.类中函数递归调用5.二叉树实现总体代码6.二叉进阶oj7.二叉树三种遍历非递归实现二叉搜索树 1.二叉搜索树概念与性能分析 什么是二叉搜索树 二叉搜索树也被称为二叉排序树&#xff0c;其也可以是一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023