java基础-day24

第01天 java基础加强

今日内容介绍

u Junit单元测试及反射概述

u 反射操作构造方法、成员方法、成员属性

u properties的基本操作

u 综合案例

第1章   Junit单元测试及反射概述

1.1  Junit单元测试

1.1.1 Junit介绍

Junit是Java语言编写单元测试框架，最直观的理解，就是取代java类中的main方法。Junit属于第三方工具，一般情况下需要导入jar包，而多数Java开发环境都集成了Junit。

1.1.2 使用方式

1. 编写测试类，简单理解Junit可以用于取代java的main方法
2. 在测试类方法上添加注解 @Test
3. @Test修饰的方法要求：public void 方法名() {…} ，方法名自定义建议test开头，没有参数。

1. 添加Eclipse中集成的Junit库，鼠标点击“@Test”，使用快捷键“ctrl + 1”，点击“Add Junit …”

1. 使用：选中方法右键，执行当前方法；选中类名右键，执行类中所有方法（方法必须标记@Test）

1. 常用注解

@Test，用于修饰需要执行的方法

@Before，测试方法前执行的方法

@After，测试方法后执行的方法

1. 常见使用错误，如果没有添加“@Test”，使用“Junit Test”进行运行，将抛异常

1.1.3 案例代码一

package com.itheima_01;

/*

* 方法：就是完成特定功能的代码块。

*

* 定义格式：

*      修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {

*          方法体;

*          return 返回值;

*      }

* 格式解释：

*      A:修饰符 目前记住 public static

*      B:返回值类型 用于限定返回值的数据类型

*      C:方法名 一个名字，为了方便我们调用方法

*      D:参数类型 用于接收调用方法时传入的数据的类型

*      E:参数名  用于接收调用方法时传入的数据的变量

*      F:方法体 完成功能的代码

*      G:return 结束方法，把返回值带给调用者

*

* 方法的两个明确：

*      A:返回值类型 明确功能结果的数据类型

*      B:参数列表 明确有几个参数，以及参数的类型

*

* 案例：

*      求两个数和的案例。

*/

public class MethodDemo {

}

1.2  类的加载

1.2.1 类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

l  加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象

l  连接

验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

l  初始化

就是我们以前讲过的初始化步骤

1.2.2 类的初始化

1. 创建类的实例

2. 类的静态变量，或者为静态变量赋值

3. 类的静态方法

4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

5. 初始化某个类的子类

6. 直接使用java.exe命令来运行某个主类

1.3      反射概述

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖这个类，使用的就是Class类中的方法，所以先要获取到每一个字节码文件所对应的Class类型对象。

反射需要用到的成员及方法：

n  Class类

n  Constructor 构造

n  Method 方法

n  Filed 字段

n  instance 实例

n  invoke 执行

1.4  反射数据准备

提供JavaBean，用于之后反射操作 JavaBean规范

1.提供私有字段，例如：private String id;

2.必须提供getter或setter方法 （可以使用快捷键生产，alt+shift+s）

3.提供无参构造方法

4.必须实现序列化接口

1.4.1 案例代码二

import java.util.Arrays;

public class Bean implements java.io.Serializable {

private String id;

private String className;

public String description;

//无参构造方法

public Bean() {

System.out.println("bean 无参构造");

}

public Bean(String id) {

super();

System.out.println("bean 1参数构造");

this.id = id;

}

private Bean(String id, String className) {

super();

this.id = id;

this.className = className;

}

//方法

public void setId(String id){

this.id = id;

}

public String getId(){

return id;

}

public void setClassName(String className){

this.className = className;

}

public String getClassName(){

return this.className;

}

//私有方法

private void show(int num){

System.out.println("私有方法 ：" + num);

}

//main方法

public static void main(String[] args) {

// * 将指定的数组转换成字符串

System.out.println(Arrays.toString(args));

}

@Override

public String toString() {

return "Bean [id=" + id + ", className=" + className+ ", desc=" + description + "]";

}

}

1.5  反射Class获取

1.5.1 三种获取方式及应用场景

1 通过类型获得

语法：类名.class

应用场景：确定类型 等

Class clazz1 = Bean.class;

2 通过实例对象获得

语法：变量.getClass()

应用场景：在方法内部通过参数获得类型 等

Bean bean = new Bean();

Class clazz2 = bean.getClass();

3 通过字符串获得

语法：Class.forName("全限定类名")

应用场景：通过配置获得字符串 等

Class clazz3 = Class.forName("com.itheima_00_Bean.Bean");

1.5.2 案例代码三

public class ClassDemo_01 {

@Test

public void demo01() throws Exception{

// 通过字符串获得

Class clazz = Class.forName("com.itheima_01_bean.Bean");

System.out.println(clazz);

}

@Test

public void demo02() throws Exception{

// 通过Java类型获得

Class clazz = Bean.class;

System.out.println(clazz);

}

@Test

public void demo03() throws Exception{

// 通过实例对象获得

Bean bean = new Bean();

Class clazz = bean.getClass();

System.out.println(clazz);

}

}

第2章   反射操作类中成员

2.1  反射操作构造方法

2.1.1 通过获取public的构造创建对象

步骤:

1.获得Class对象

2获得构造

3.通过构造对象获得实例化对象

import java.lang.reflect.Constructor;

import org.junit.Test;

import com.itheima_01_bean.Bean;

public class ConstructorDemo_01 {

@Test

public void demo01(){

//触发 无参构造方法

Bean bean = new Bean();

}

@Test

public void demo02() throws Exception{

/* 通过 无参构造方法 获得实例对象

* 1.获得Class对象

* 2.通过clazz获得无参构造

* 3.通过构造对象获得实例化对象

*/

//1 获得Class

Class clazz = Class.forName("com.itheima_01_bean.Bean");

//2 获得构造对象 , 相当于：Bean()

// * getConstructor() 获得指定形参列表的构造方法

Constructor cons = clazz.getConstructor();

//3 获得实例 , 相当于：new Bean()

// * newInstance() 创建实例对象，需要设置实际参数

Object obj = cons.newInstance();

}

@Test

public void demo03() throws Exception{

/* 通过 有参构造 获得实例

* Bean bean = new Bean("b001");

*/

// 1 获得Class对象

Class clazz = Class.forName("com.itheima_01_bean.Bean");

// 2 获得构造，必须指定形参

Constructor cons = clazz.getConstructor(String.class);

// 3 获得实例对象，必须设置实际参数

Object obj = cons.newInstance("b002");

System.out.println(obj);

}

@Test

public void demo04() throws Exception{

// 无参构造 快速获得实例方式

//1 获得Class

Class clazz = Class.forName("com.itheima_01_bean.Bean");

//2 通过clazz直接创建对象

Object obj = clazz.newInstance();

}

}

2.1.2 通过获取private的构造方法创建对象

步骤:

1 获得Class对象

2.获得 指定形参  私有构造

3.通知jvm，运行实例化私有构造

4.创建实例，并设置实际参数

@Test

public void demo05() throws Exception{

// 通过 私有构造方法 创建实例对象

//1 获得Class对象

Class clazz = Class.forName("com.itheima_01_bean.Bean");

//2 获得 指定形参  私有构造

// * clazz.getConstructor(...) 获得指定对象的指定的public构造方法

// * clazz.getDeclaredConstructor( ... ) 获得指定对象的指定的任意构造方法

Constructor cons = clazz.getDeclaredConstructor(String.class ,String.class);

//3 通知jvm，运行实例化私有构造（默认不允许）

cons.setAccessible(true);

//4 创建实例，并设置实际参数

Object obj = cons.newInstance("b001","名称");

System.out.println(obj);

}

第3章   反射操作成员方法

3.1     反射public方法

通过反射运行public方法流程

1 获得实例

2 通过 setId 方法，设置数据

2.1获得方法 ，需要明确形参列表，setId

2.2 执行方法 ，bean.setId(...)

3.确定实例对象，并执行确定方法，具体实际参数

3.2  案例代码四

public class MethodDemo_01 {

@Test

public void demo01(){

Bean bean = new Bean();

bean.setId("b001");

String id = bean.getId();

System.out.println(id);

}

@Test

public void demo02() throws Exception{

//1 获得实例

Class clazz = Class.forName("com.itheima_01_bean.Bean");

Object obj = clazz.newInstance();

//2 通过 setId 方法，设置数据

//2.1 获得方法 ，需要明确形参列表，setId

Method method = clazz.getMethod("setId", String.class);

//2.2 执行方法 ，bean.setId(...)

// * 确定实例对象，并执行确定方法，具体实际参数

method.invoke(obj, "b002");

System.out.println(obj);

}

@Test

public void demo03() throws Exception{

//1 获得实例

Class clazz = Class.forName("com.itheima_01_bean.Bean");

Object obj = clazz.newInstance();

//2 通过 setId 方法，设置数据

//2.1 获得方法 ，需要明确形参列表，setId

Method method = clazz.getMethod("setId", String.class);

//2.2 执行方法 ，bean.setId(...)

// * 确定实例对象，并执行确定方法，具体实际参数

method.invoke(obj, "b002");

//3 通过  getId 方法，获得数据

Method getMethod = clazz.getMethod("getId");

String str = (String) getMethod.invoke(obj);

System.out.println(str);

}

}

3.3  反射private方法

通过反射运行public方法流

1 获得实例

2 执行方法

2.1 获得方法

2.2 强制设置运行访问私有访问（暴力）

2.3 执行方法

3.4  案例代码五

public class MethodDemo_02 {

@Test

public void demo01() throws Exception{

// 执行 bean 私有方法

//1 获得实例

Class clazz = Class.forName("com.itheima_01_bean.Bean");

Object obj = clazz.newInstance();

//2 执行方法

// 2.1 获得方法

// * clazz.getMethod(name,... ) 只能获得public类型方法

// * clazz.getDeclaredMethod(name,... ) 获得已声明的方法

Method method = clazz.getDeclaredMethod("show", int.class);

// 2.2 强制设置运行访问私有访问（暴力）

method.setAccessible(true);

// 2.3 执行方法

Object r = method.invoke(obj, 18);

System.out.println(r);

}

@Test

public void demo02() throws Exception{

// 执行 静态方法 main

//1 获得实例，不需要

//2 执行方法，必须需要Class对象

//1 获得Class对象

Class clazz = Class.forName("com.itheima_01_bean.Bean");

//2获得main方法

Method method = clazz.getMethod("main", String[].class);

//3 执行main方法

// * 参数1：为实例对象(变量名)，static方法不需要

// * 参数2：main方法执行的实际参数

// ** 可变参数在执行时，JVM内部将传递实参数组打散，变成多个参数。

// **** method.invoke(null, args);

// 等效  method.invoke(null, "abc","123","xxx");

String[] args = {"abc","123","xxx"};

//method.invoke(null, args);        //错误写法

// * 数组参数需要特殊处理

// ** 方式1：将 String[]转换成Object,可变参数将不处理数组

method.invoke(null, (Object)args);

// ** 方法2：将提供二维数组，args将作为二维数组的第一个数。

method.invoke(null, new Object[] {args});

}

}

第4章   反射操作成员属性

4.1  反射public属性

反射public属性执行流程

1 获得实例对象

2 给字段赋值

3 获得字段值

4.2  案例代码六

public class FieldDemo_01 {

@Test

public void demo01() throws Exception{

//1 获得实例对象

Class clazz = Class.forName("com.itheima_01_bean.Bean");

Object obj = clazz.newInstance();

//2 给字段赋值

Field field = clazz.getField("description");

field.set(obj, "描述");

//3 获得字段值

String str = (String) field.get(obj);

System.out.println(str);

}

}

4.3  反射private属性

反射private属性流程

1 获得实例

2 获得声明的字段(私有)

3 设置运行访问私有（暴力）

4 设置数据

5 获得数据

4.4  案例代码七

@Test

public void demo02() throws Exception{

//私有字段

//1 获得实例

Class clazz = Class.forName("com.itheima_01_bean.Bean");

Object obj = clazz.newInstance();

//2 获得声明的字段(私有)

// * clazz.getField(name)   获得公共字段

// * clazz.getDeclaredField(name) 获得声明字段(含私有)

Field field = clazz.getDeclaredField("className");

//3 设置运行访问私有（暴力）

field.setAccessible(true);

//4 设置数据

field.set(obj, "名称");

//5 获得数据

String className = (String) field.get(obj);

System.out.println(className);

}