Java语言学习笔记----基础加强

第七章：基础加强

第一节： Junit单元测试

1.1 测试分类

1、黑盒测试

**黑盒测试：**不需要写代码，给输入值，看程序是否能够输出期望的值

2、白盒测试

**白盒测试：**需要写代码。关注程序具体的执行流程。

Junit单元测试是白盒测试的一种

1.2 Junit测试的使用步骤

1、定义一个测试类（测试用例）

• 建议：
  • 测试类名：被测试类名+Test
  • 包名：xxx.xxx.xx.test

2、定义测试方法：可独立运行

• 建议：
  • 方法名：test+测试方法名
  • 返回值：void
  • 参数列表：空参

3、给方法加@Test

4、导入Junit的依赖环境

5、判定结果

• **红色：**失败
• **绿色：**成功
• 一般我们会使用断言操作来处理结果：
  • Assert.assertEquals(期望的结果,运算的结果);

1.3 Junit注解@Before @After

初始化方法@Before

**初始化方法:**修饰的方法会在测试方法之前被执行

释放资源方法@After

**释放资源方法：**修饰的方法会在测试方法之后被执行

public class CalculatorTest_plus {
    @Before
    public void testBefore(){
        System.out.println("start");
    }

    @Test
    public void testadd(){
        Junit_Calculator ca=new Junit_Calculator();
        int result=ca.add(1,2);
        Assert.assertEquals(3,result);
    }

    @Test
    public void testSub(){
        Junit_Calculator ca=new Junit_Calculator();
        int result=ca.sub(3,1);
        Assert.assertEquals(2,result);
    }

    @After
    public void testafter(){
        System.out.println("close");
    }
}

第二节：反射

2.1 概述

**框架：半成品软件。**可以在框架的基础上进行软件开发，简化编码

反射：框架设计的灵魂，将类的各个组成部分封装为其他对象，这就是反射机制

好处：

1、可以在程序的运行过程中，操作这些对象

2、可以解耦，提高程序的可扩展性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sZTR3pHI-1611641809114)(图片/45.png)]

2.2 获取字节码Class类对象的三种方式

1、Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象

多用于配置文件，将类名定义在配置文件中来读取文件、加载类

//1、Class.format("全类名")
Class cls=Class.forName("day020.Rufluct.Person");
System.out.println(cls);//class day020.Rufluct.Person

2、类名.class：通过类名的属性class来获取

多用于参数的传递

//2、类名.class
Class cls2=Person.class;
System.out.println(cls2);//class day020.Rufluct.Person

3、对象.getClass()：getClass()方法在Object类中定义

多用于对象的获取字节码的方式

//3、对象.getClass()
Person one=new Person();
Class cls3=one.getClass();
System.out.println(cls3);//class day020.Rufluct.Person

结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是一个

2.3 Class对象功能概述

一、获取功能

1、获取成员变量们

• public Field[] getFields()：获取所有public修饰的成员变量

Field[] fields=personcls.getFields();
for (Field field:fields) {
	System.out.println(field);
}

• public Field getField(String name)：获取指定的被public修饰的成员变量

Field pa=personcls.getField("name1");

• public Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符

Field[] fields1=personcls.getDeclaredFields();
for (Field field:fields1) {
	System.out.println(field);
}

• public Field getDeclaredField(String name):获取所有的指定的成员变量

Field field=personcls.getDeclaredField("name");
//忽略访问权限修饰符的安全检查
field.setAccessible(true);//暴力反射
field.set(p,"Hello");
Object valu2=field.get(p);
System.out.println(valu2);//Hello

Field:成员变量的操作

1、设置值：set(Object obj)

pa.set(p,"abc");

2、获取值：get(Object obj)

Object value=pa.get(p);

2、获取构造方法们

• public Constructor<?>[] getConstructors()：

Constructor constructor=personClass.getConstructor(String.class,int.class);

• public Constructor<T> getConstructor(类<?>...parameterTypes)
• public Constructor<?>[] getDeclaredConstructors()

也可以用暴力反射方法：

constructor.setAccessible(true);

• public Constructor<T> getDeclaredConstructor(类<?>...parameterTypes)

Constructor：构造方法的操作

创建对象：T newInstance(Object... initargs)

Object one=constructor.newInstance("张三",23);

**注意：**如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance()方法

Object o2=personClass.newInstance();

3、获取成员方法们

• public Method[] getMethods()
• public Method getMethod(String name,类<?>...parameterTypes)
• public Method[] getDeclaredMethods()
• public Method getDeclaredMethod(String name,类<?>...parameterTypes)

参数：

String name:方法名 类<?>…parameterTypes：参数名

Method：方法对象

执行方法：Object invoke(Object obj,Object...args)

参数：Object obj 真实的对象 Object…args：参数列表

method.invoke(one);

获取方法名：

• public String getName：获取方法名

Method[] methods1=personClass.getDeclaredMethods();
for (Method method:methods1) {
	System.out.println(method.getName());
}

4、获取类名

• public String getName()

2.4 反射案例

**需求：**写一个“框架”，在不改变任意代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

**实现：**1、配置文件 2、反射

步骤：

1、将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2、在程序中加载读取配置文件

3、使用反射技术加载类文件进内存

4、创建对象

5、执行方法

第三节：注解

3.1 概述

**注释：**用文字描述程序的，给程序员看的

**注解：**说明程序的，给计算机看的

注解定义：注解也叫元数据，一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明、注释

概念描述：

1、JDK1.5之后的特性

2、它是说明程序的

3、使用注解：@注解名称

3.2 作用分类

• 编写文档

通过代码里标识的元数据（注解）生成文档【生成文档doc文档】

• 代码分析

通过代码里标识的元数据（注解）对代码进行分析【使用反射】

• 编译检查

通过代码里标识的元数据（注解）让编译器能够实现基本的编译检查【Override】

3.3 JDK中预定义的一些注解

• @Override

  检测被该注解标注的方法是否是继承自父类（接口）的

• @Deprecated

  将该注解标注的内容表示为已过时

• @SuppressWarnings()

  压制警告,参数一般传递"all" @SuppressWarnings("all")

@SuppressWarnings("all")
public class In_JDK {
    public void show2(){
        //替代show1方法
    }

    @Override
    public String toString() {
        return super.toString();
    }

    @Deprecated
    public void show1(){
        //有缺陷
    }

}

3.4 自定义注解

格式：

元注解
public @interface 注解名称{}

注解的本质：

注解本质上就是一个接口，该接口默认继承java.lang.annotation.Annotation接口

**属性：**接口中的抽象方法

属性的要求：

1、属性的返回值类型：基本数据类型、String、枚举、注解、以上类型的数组

2、定义了属性，在使用时需要给属性赋值。

• 如果定义属性时，使用default关键字给属性值默认初始化值，则使用注解时，可以不给注解赋值
• 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可
• 数组赋值时，值使用{}包裹。如果数组只有一个值，则{}省略

@My_Anno(show1 = 0, show2 = "", per = Person.p1, anno2 = @My_Anno2, s2 = {"abc","bbb"})
    public void show(){}

元注解：用于描述注解的注解

1、@Target:描述注解能够作用的位置

@Target(value = {ElementType.TYPE/METHOD/FIELD})

取值：

**TYPE:**可以作用于类上

**METHOD：**可以作用于方法上

**FIELD：**可以作用于成员变量上

2、@Retention：描述注解被保留的阶段

@Retention(RetentionPolicy.RUNTIME)//当前被描述的注解，会保留到class字节码文件中，并被JVM读取到，一般使用RUNTIME

3、@Documented：描述注解是否被抽取到api文档中

4、@Inherited：描述注解是否被子类继承

3.5 在程序中使用（解析）注解

**解析注解：**获取注解中定义的属性值
1、获取注解定义位置的对象(Class,Method,Field)

2、获取指定的注解

• getAnnotation(Class)

• //其实就是在内存中生成了一个该注解接口的子类实现对象
          Reflect annotation=cls.getAnnotation(Reflect.class);
  //        public class ReflectImpl implements Reflect{
  //            public String className(){
  //                return "Day031.Review_Reflect.Sleep";
  //            }
  //            public String methodName(){
  //                return "sleep";
  //            }
  //        }
  

3、调用注解中的抽象方法获取配置的属性值

@Reflect(className = "Day031.Review_Reflect.Sleep",methodName ="sleep")
public class Reflect_Test {
    public static void main(String[] args) throws Exception {

        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<Reflect_Test> cls=Reflect_Test.class;
        //2.获取上边的注解对象
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        Reflect annotation=cls.getAnnotation(Reflect.class);

        //3.调用注解对象中定义的抽象方法，获取返回值
        String classname=annotation.className();
        String methodname=annotation.methodName();

        Class clss=Class.forName(classname);
        Object obj=clss.newInstance();
        Method method=clss.getMethod(methodname);
        method.invoke(obj);
    }
}

小结：

1、以后大多数时候，我们会使用注解，而不是自定义注解

2、注解给谁用？

• 编译器
• 解析程序

3、注解不是程序的一部分，可以理解为注解就是一个标签