日度归档:2020年11月19日

Java中Class类的基本使用

1、获取类对象的几种方式

Class.forName(String name)类名.class实例对象.getClass()

private static void getClassDemo() throws Exception{
    Class cls1 = Class.forName("java.lang.Object");
    System.out.println(cls1);   // class java.lang.Object
    Class cls2 = Object.class;
    System.out.println(cls2);   // class java.lang.Object
    Object obj = new Object();
    Class cls3 = obj.getClass();
    System.out.println(cls3);   // class java.lang.Object
    System.out.println(cls1 == cls2);   // true
    System.out.println(cls1 == cls3);   // true
}

继续阅读

Java中单元测试框架jUnit的基本使用

  • 单元测试一般写在一个单独的包内;

  • 单元测试的类名对应被测试的类名+Test,如:Person –> PersonTest;

  • 单元测试的方法名对应test+被测试的方法名,如:method –> testMethod;

  • 单元测试的方法一般无参无返回值;

  • 测试方法中使用断言来检测预期结果;

  • 单元测试的方法上加注解@Test,需要导入jUnit框架;

  • 单元测试类中一般饮食@Before和@After注解的方法,这两个方法会分别在测试的前后调用

    被测试的类:

    package com.yusian.junit;
    
    public class Calculator {
      public int add(int a, int b) {
          return a + b;
      }
    
      public int sub(int a, int b) {
          return a - b;
      }
    }
    
    

    单元测试类:

    package com.yusian.test;
    
    import com.yusian.junit.Calculator;
    import org.junit.After;
    import org.junit.Assert;
    import org.junit.Before;
    import org.junit.Test;
    
    public class CalculatorTest {
    
      @Before // Before可用于资源的申请,对应的是After
      public void init() {
          System.out.println("测试开始前执行...");
      }
    
      @Test
      public void testAdd() {
          Calculator c = new Calculator();
          int ret = c.add(1, 2);
          // System.out.println(ret);
            // 使用断言来判断结果是否与预期一致,如果不一致将显示测试失败
          Assert.assertEquals(3, ret);
      }
    
      @Test
      public void testSub() {
          Calculator c = new Calculator();
          int ret = c.sub(4, 4);
          // System.out.println(ret);
          Assert.assertEquals(0, ret);
      }
    
      @After // After用于资源的释放,对应的是Before
      public void dealloc() {
          System.out.println("测试结束后执行...");
      }
    }
    

Java内置的几个函数式接口的基本使用

  1. 相关类:SupplierConsumerPredicateFunction
  2. 什么是函数式接口

    • 有且只有一个抽象方法的接口被称作函数式接口
    • 函数式接口可以直接写成Lambda表达式
    • 函数式接口还可以写成方法引用的方式
    • 函数式接口对外展示的是一个规范,只需要满足这种规范即可成为其实现
    • 函数式接口可以类比为多态在函数式结构上的实现
    package com.yusian.function;
    
    import java.util.function.Supplier;
    
    /**
    * Supplier是一个函数式接口,返回任意类型数据,是一个容器
    * 他是对所有无参并返回一个对象的结构抽象,一切无参并返回对象的方法都可以成为他的实现
    * 这使得编程变得更加开放,可以想像是多态在函数式编程方式上的实现
    */
    public class SupplierDemo {
    
       public static void main(String[] args) {
           // 1、匿名内部类
           Supplier<Person> sup1 = new Supplier<Person>() {
               @Override
               public Person get() {
                   return new Person();
               }
           };
           Person p1 = sup1.get();
    
           // 2、Lambda表达式
           Supplier<Person> sup2 = () -> new Person();
           Person p2 = sup2.get();
    
           // 3、方法引用
           Supplier<Person> sup3 = Person::new;
           Person p3 = sup3.get();
    
           // 4、本地方法模拟
           Person p4 = supplier();
    
           // 5、只要满足函数式结构就可以
           Supplier<Person> sup5 = SupplierDemo::supplier;
           Person p5 = sup5.get();
    
           System.out.println(p1);
           System.out.println(p2);
           System.out.println(p3);
           System.out.println(p4);
           System.out.println(p5);
       }
    
       /**
        * 获取一个Person实例对象
        * @return Person
        */
       public static Person supplier() {
           return new Person();
       }
    }
    

    继续阅读