知新_RL

这个屌丝很懒，什么也没留下！

热门标签

JAVA基础篇——JAVA高级（与框架有关的知识）

作者：知新_RL | 2024-07-09 15:41:44

踩

java高级

十九、JAVA高级

1. 单元测试

针对最小的功能单元（方法），编写测试代码对其进行正确性测试。

main方法进行单元测试的问题：

只能在main里面调用别的方法进行测试
无法自动化测试，一个方法失败会影响其他方法的测试
无法获得测试报告，需要程序员自己去观察测试是否成功

Junit单元测试框架

第三方公司开源，开发工具已集成
一键自动化测试
生成测试报告

Junit使用步骤

导入Junit的jar包到项目（IDEA已集成）
为业务类中的业务方法定义对应的测试方法（公有、无参、无返回值）
必须加**@Test**，加了在之后才可测试运行
开始测试，绿色通过，红色有错

自动化测试

在项目上右键Run All Test

案例

工具类

public class StringUtil {
    public static void printNumber(String name) {
        System.out.println("名字的长度是：" + name.length());
    }

    // 求最大索引
    public static int getMaxIndex(String data) {
        if (data == null) {
            return -1;
        }
        return data.length();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

测试类

public class StringUtilTest {
    @Test
    public void testPrintNumber() {
        StringUtil.printNumber("admin");
//        StringUtil.printNumber(null);
    }

    @Test
    public void testGetMaxIndex() {
        int r1 = StringUtil.getMaxIndex("admin");

        // 断言，看实际期望的和程序输出的是否有出入
        Assert.assertEquals("有问题", 4, r1);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Junit框架的常见注解

在测试方法之前执行的方法——初始化资源

在测试方法之后执行的方法——释放资源

测试类

public class StringUtilTest {
    @Before  // 每个测试方法执行之前执行一次
    public void test1() {
        System.out.println("----");
    }

    @BeforeClass  // 所有测试方法执行之前执行一次
    public static void test11() {
        System.out.println("String测试类开始执行了");
    }

    @After  // 每个测试方法执行之后执行一次
    public void test2() {
        System.out.println("====");
    }

    @AfterClass  // 所有测试方法执行之前执行一次
    public static void test22() {
        System.out.println("String测试类执行结束了");
    }

    @Test
    public void testPrintNumber() {
        StringUtil.printNumber("admin");
//        StringUtil.printNumber(null);
    }

    @Test
    public void testGetMaxIndex() {
        int r1 = StringUtil.getMaxIndex("admin");
        System.out.println(r1);

        // 断言，看实际期望的和程序输出的是否有出入
        Assert.assertEquals("有问题", 4, r1);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2. 反射

学习框架、理解源码/开发框架

java.lang.reflect

概念： 加载类，并允许以编程的方式解剖类中的各种成分（成员变量、方法、构造器等）——反序列化/向外界展示已经封装好的内部东西

学什么： 如何获取类的信息并操作他们

步骤：

加载类，获取类的字节码：Class对象
获取类的构造器：Constructor对象
获取类的成员变量：Field对象
获取类的成员方法：Method对象

1）获取Class对象的三种方式

Class c1 = 类名.class
调用Class提供的方法：public static Class forName(String package);

Object提供的方法：public Class getClass(); Class c3 = 对象.getClass();

public class Test1Class {
    public static void main(String[] args) throws Exception {
        // 方式一
        Class c1 = Student.class;
        System.out.println(c1.getName());  // 全类名 com.itheima.d2_reflect.Student
        System.out.println(c1.getSimpleName());  // 简名 Student

        // 方式二
        Class c2 = Class.forName("com.itheima.d2_reflect.Student");
        System.out.println(c2.getName());  // com.itheima.d2_reflect.Student

        // 方式三，通过类的实例对象
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3.getName());  // com.itheima.d2_reflect.Student

        System.out.println(c1 == c2);  // true
        System.out.println(c2 == c3);  // true

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2）获取Constructor对象

类

public class Cat {
    private String name;
    private int age;

    private Cat() {
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

获取Constructor对象

public class TestConstructor {
    @Test
    public void testGetConstructor() {
        // 1. 首先要获取类的class对象
        Class c = Cat.class;
        // Class.forName("com.itheima.d2_reflect.Cat");
        // 对象.getClass()
        // 2. 获取全部构造器
        Constructor[] constructors = c.getConstructors();  // 只能获取public修饰的构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->" + constructor.getParameterCount());
        }

        Constructor[] constructors1 = c.getDeclaredConstructors();  // 获取任何修饰符修饰的构造器
        for (Constructor constructor : constructors1) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    @Test
    public void testGetOneConstructor() throws Exception {
        // 1. 首先要获取类的class对象
        Class c = Cat.class;
        // Class.forName("com.itheima.d2_reflect.Cat");
        // 对象.getClass()
        // 2. 获取1个构造器
        Constructor constructor1 = c.getDeclaredConstructor();  // 获取无参构造器
        System.out.println(constructor1.getName() + "--->" + constructor1.getParameterCount());

        Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);  // 获取任何修饰符修饰的构造器
        System.out.println(constructor2.getName() + "===>" + constructor2.getParameterCount());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

作用：

初始化对象返回

@Test
public void testGetOneConstructor() throws Exception {
    // 1. 首先要获取类的class对象
    Class c = Cat.class;
    // Class.forName("com.itheima.d2_reflect.Cat");
    // 对象.getClass()
    // 2. 获取1个构造器
    Constructor constructor1 = c.getDeclaredConstructor();  // 获取无参构造器
    System.out.println(constructor1.getName() + "--->" + constructor1.getParameterCount());
    // 重点！！！
    constructor1.setAccessible(true);  // 禁止检查访问权限，也就是不管private还是public，都能创建对象，会破坏封装性
    Cat cat = (Cat) constructor1.newInstance();  // 调用此构造器，并传入参数，完成对象的初始化

    Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);  // 获取任何修饰符修饰的构造器
    System.out.println(constructor2.getName() + "===>" + constructor2.getParameterCount());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3）获取成员变量Field

public Field[] getFields()——获取全部public修饰的成员变量

public Field[] getDeclaredFields()——获取全部成员变量

public Field getField(String name)——根据成员变量的名字，获取某个成员变量，只能获取public修饰的

public Field getDeclaredField(String name)——根据成员变量的名字，获取某个成员变量

作用： 赋值、取值

void set(Object obj, Object value);

Object get(Object obj);

public void setAccessible(boolean flag); // 禁止访问权限

4）获取成员方法Method

同上

作用：执行

public Object invoke(Object obj, Object……args); // 出发某个对象的该方法执行

public void setAccessible(boolean flag); /// 设置true，表示禁止检查访问控制

反射的作用

基本作用：可以得到一个类的全部成分然后操作
可以破坏封装性
适合做Java框架，基本上，主流的框架都会基于反射设计出一些通用功能

3. 注解

JAVA代码里的特殊标记

作用： 让其他程序根据在注解信息来决定怎么执行该程序

自定义注解： 自己定义注解

格式：

public @interface 注解名称{

public 属性类型属性名() default 默认值;

}

/*
* 自定义注解
*/
public @interface MyTest1 {
//    String value();  // 特殊属性，只有这一个属性时，或者后面是有默认值的，用的时候可以不写名字
    String aaa();
    boolean bbb() default true;
    String[] ccc();
}
1
2
3
4
5
6
7
8
9

@MyTest1(aaa = "小鱼0135", ccc = {"嘻嘻", "嘎嘎"})
public class AnnotationTest1 {
    @MyTest1(aaa="小君", bbb=false, ccc={"123"})
    public void test1(){
    }
}
1
2
3
4
5
6

原理：

注解本质是一个接口，Java中所有注解都继承了Annotation接口
一个实现类对象，实现了该注解以及Annotation接口

元注解：修饰注解的注解

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

/*
* 自定义注解
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest1 {
//    String value();  // 特殊属性，只有这一个属性时，或者后面是有默认值的，用的时候可以不写名字
    String aaa();
    boolean bbb() default true;
    String[] ccc();
}
1
2
3
4
5
6
7
8
9
10
11

注解的解析

判断类上、方法上、成员变量上是否存在注解，并把注解里面的内容给解析出来

如何解析注解：

要解析谁上面的注解，就要先拿到谁（要解析类上面的注解，应该先获取该类的Class对象，再通过Class对象解析其上面的注解；Class、Method、Field、Constructor都实现了AnnotatedElement接口，他们都有解析注解的能力）

/*
* 注解的解析
* */
public class AnnotationTest3 {
    @Test
    public void parseClass() {
        // 1. 先得到Class对象
        Class c =  Demo.class;
        // 2. 解析类上的注解
        // 判断类上是否包含了注解
        if(c.isAnnotationPresent(MyTest4.class)) {
            MyTest4 myTest4 = (MyTest4) c.getDeclaredAnnotation(MyTest4.class);
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(Arrays.toString(myTest4.bbb()));
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

应用场景：结合反射等做框架

整理：就是做框架的时候会自定义很多注解，说明怎么执行这段程序（功能），那别人使用这个功能就要完成一些操作，这个时候就要用到反射，拿出类信息、构造器信息、成员变量和方法等信息，执行一些初始化、取值赋值、执行等一些操作。

4. 动态代理

程序为什么需要代理

对象如果干的事太多，可以通过代理来转移部分职责

代理的样子

对象有什么方法想被代理，代理一定要有对应的方法

代理如何知道有什么方法需要代理

接口：想代理的方法

案例：

BigStar

public class BigStar implements Star{
    private String name;

    public BigStar(String name) {
        this.name = name;
    }

    // 唱歌行为
    public String sing(String name) {
        System.out.println(this.name + "正在唱" + name);
        return "唱完了！谢谢大噶！";
    }

    // 跳舞行为
    public void dance() {
        System.out.println(this.name + "正在跳舞！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

想要代理的接口类Star

// 指明有哪些方法需要被代理
public interface Star {
    String sing(String name);
    void dance();
}
1
2
3
4
5

代理对象的类

public class ProxyUtil {
    // 生成代理对象，并返回
    public static Star creatrProxy(BigStar bigStar) {
        // Java为产生代理，设计了Proxy类。java.lang.reflect
/*        newProxyInstance(ClassLoader loader,
                Class<?>[] interfaces,
                InvocationHandler h)*/
        // 参数1：用于指定一个类的加载器
        // 参数2：指定生成的代理的样子，也就是方法，接口数组
        // 参数3：指定生成的代理对象要干什么事情，InvocationHandler是一个接口，也就是要实现一个匿名内部类，指定对象要要干的事情
        Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class}, new InvocationHandler() {
                    @Override  // 回调方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 代理对象，要调用的方法，调用的方法需要传递的参数
                        // 代理对象要做的事情
                        if (method.getName().equals("sing")) {
                            System.out.println("准备话筒，收钱20万");  // 代理要干的事情
                            // return method.invoke(bigStar, args);
                        } else if(method.getName().equals("dance")) {
                            System.out.println("准备场地，收钱1000万");
                            // return method.invoke(bigStar, args);
                        }
                        return method.invoke(bigStar, args);
                    }
                });  // 产生一个代理对象
        return starProxy;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

主程序

public class Test {
    public static void main(String[] args) {
        BigStar s = new BigStar("杨");
        Star starProxy = ProxyUtil.creatrProxy(s);

        String rs = starProxy.sing("好日子");
        System.out.println(rs);

        starProxy.dance();
    }
}
1
2
3
4
5
6
7
8
9
10
11

一些通用的功能可以通过代理在不修改原代码的情况下，为不同对象添加通用功能

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/802877