Java day19—— Lambda表达式、可变长参数、JUnit单元测试

Lambda表达式

• JDK1.8 函数式编程思想
• 面向对象思想: 什么对象, 做什么, 结果是什么
  函数式编程思想: 强调做什么，而不是以什么形式做。

语法

(参数列表) -> {一些代码}

(参数列表): 表示要重写的抽象方法的参数列表
-> : 固定语法, 指向/传递的意思
{一些代码}: 要重写的方法体

使用前提

1.实现一个接口
2.接口中只有一个抽象方法
3.接口对象是作为方法参数使用的
4.实现函数式接口@FunctionalInterface

与匿名内部类比较

Lambda 用来取代匿名内部类的

• 匿名内部类: 本质还是类, 编译后也会生成字节码文件, 运行时也要加载
• Lambda: 本质是一个函数, 编译后不会有字节码文件, 直接从内存中获取效率更高

public interface MyInterface {
    @Deprecated
    int sum(int a, int b);
}

public class DemoMyInterface {
    public static void main(String[] args) {
        int s = method1(new MyInterface() {
            @Override
            public int sum(int a, int b) {
                return a + b;
            }
        });
         调用method1方法, 需要传递MyInterface对象,
         可以使用匿名内部类, 就可以使用lambda表达式优化
        int s = method1((int a, int b) -> {
                return a + b;
            }, 1, 3);
        System.out.println(s);

        // 继续优化
        int s = method1(
                (a, b) -> a + b
        , 1, 3);
        System.out.println(s);
    }



    // 需要将接口对象作为方法参数, 才可以使用Lambda表达式
    public static int method1(MyInterface in, int a, int b) {
        // 在method1中使用接口对象in的sum方法
        return in.sum(a, b);
    }

可推导即可省略

1. () 中的参数类型, 可以省略, 如果有多个参数, 每个参数类型都要一起省略
2. {} 中如果只有一行代码, 不论这个方法有没有返回值, 那么[{} return ;] 可以省略
   {} return ; 必须一起省略
3. () 中如果只有一个参数, () 可以省略, 和类型一起省略
   () 中如果没有参数, 必须写 ()

函数式接口

接口中只有一个抽象方法, 默认方法\静态方法\私有方法 随意
@FunctionalInterface -> 注解
注解: JDK 1.5 属于程序的一部分, 可以取代一部分配置信息
@Override -> 检测方法是不是重写
@SuppressWarnings -> 压制警告
@Deprecated -> 标记一个类或者方法或者变量, 过时的
@FunctionalInterface -> 检测一个接口是不是函数式接口

可变长参数

参数类型… 参数名 -> 取代数组
int[] arr -> int… arr
JDK1.5后, 修改为可变长参数
1.方法中, 除了可变长参数, 还有别的参数, 可变长参数必须放在参数列表最后
2.而且一个方法中, 只能有一个可变长参数

传入n个整数值, 将传入的整数相加求和, 并返回
public static void main(String[] args) {
        sum(2, 4);
        sum(1,2,3,4,5);
        sum(1);
        sum();
        sum(1, 2, 3);
        sum(1, 2, 3, 4);

    }
public static int sum(int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
    public static void method1(int a, String... ss) {

    }
}

JUnit单元测试

单元测试 -> 以方法为单位, 可以取代主方法
System.out.println(); -> 打桩测试
Debug -> 断点测试
JUnit -> 单元测试

原理

别人写好的代码, 我们想要使用
1.将别人写好的代码工程, 打包 jar 文件
是将编译后的字节码文件打包的
2.在自己的工程中 关联这个jar文件 -> 添加依赖
3.代码中直接使用 import

使用步骤

JUnit使用步骤:
1.在工程中创建一个文件夹lib
2.将2个jar包复制到lib中
3.选择jar包 右键 -> Add as Library… 默认添加即可
4.写一个测试类, 在其中写一个方法[不需要返回值,不需要参数]
5.在方法上添加注解 @Test
6.运行这个方法即可

常用注解

@Test: 测试的方法, 可以直接运行
@Before: 在测试方法之前调用的
@After: 在测试方法之后调用的

public class Demo01 {
    @Before  // 在所有@Test之前执行的
    public void before() {
        System.out.println("hello Junit!");
    }
    @After // 在所有@Test之后执行的
    public void after() {
        System.out.println("bye Junit!");
    }
    @Test // 取代主方法的
    public void method01() {
        System.out.println("hello method1");
    }
    @Test
    public void method2() {
        System.out.println("hello method2");
    }

hello Junit!
hello method1
bye Junit!
hello Junit!
hello method2
bye Junit!