面向对象进阶12

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量40 收藏
点赞数
分类专栏： java 文章标签： junit 单元测试 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43219411/article/details/129092196
版权

一、单元测试

1.单元测试概述

（1）单元测试

  • 针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性

（2）Junit单元测试框架

  • JUnit是使用Java语言实现的单元测试框架，是开源的
  • 所有的IDE工具都集成了JUnit

（3）JUnit优点

  • 灵活选择执行哪些测试方法，可一键执行全部测试方法；
  • Junit可生成全部方法的测试报告；
  • 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
2.单元测试入门
  1. 将JUnit的jar包导入项目
  2. 编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法
  3. 在测试方法上使用@Test注解，标注该方法是一个测试方法
  4. 在测试方法中完成被测试方法的预期正确性测试
  5. 选中测试方法，选择“JUnit”运行。
3.单元测试常用注解

在这里插入图片描述

二、反射

1.反射概述

（1）反射概述

  • 反射是指对于任何一个Class类，在“运行的时候”都可以直接得到这个类全部成分；
  • 在运行时，可以直接得到这个类的构造器对象：Constructor
  • 在运行时，可以直接得到这个类的成员变量对象：Field
  • 在运行时，可以直接得到这个类的成员方法对象：Method
  • 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制

（2）反射的关键

  • 反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分
    在这里插入图片描述
2.反射获取类对象

反射的第一步：获取Class类的对象

public class Test {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("d1_reflect_class.Student");
        System.out.println(c);

        //2.类名.class
        Class c1 = Student.class;
        System.out.println(c1);

        //3. 对象.getClass()获取对象对应类的Class对象
        Student s = new Student();
        Class c2 = s.getClass();
        System.out.println(c2);
    }
}
3.反射获取构造器对象
  • 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象
    //1.getConstructors:
    //获取全部的构造器：只能获取public修饰的构造器
    //Constructor[] getConstructors
    @Test
    public void getConstructors(){  //只能拿public修饰的构造器
        //o1.获取类对象
        Class c = Student.class;
        //o2.提取类中的全部构造器对象
        Constructor[] constructors = c.getConstructors();
        //o3. 遍历构造器看有没有拿到
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName()+"1===>"+constructor.getParameterCount());
        }
    }

    //2.getDeclaredConstructors():
    //获取全部的构造器，只要你敢写，这里就能拿到，无所谓权限是否可及
    @Test
    public void getDeclaredConstructors(){
        //o1.获取类对象
        Class c = Student.class;
        //o2.提取类中的全部构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        //o3. 遍历构造器看有没有拿到
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName()+"2===>"+constructor.getParameterCount());
        }
    }

    //3.getConstructor(Class...parameterTypes)
    //获取某个构造器，只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception{
        Class c = Student.class;
        //o2.定位单个构造器对象
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName()+"3===>"+cons.getParameterCount());
    }

    //4.getDeclaredConstructor
    //获取某个构造器，只要你敢写，这里就能拿到，无所谓权限是否可及
    @Test
    public void getDeclaredConstructor() throws Exception{
        //o1.获取类对象
        Class c = Student.class;
        //o2.提取类中的单个构造器对象
        Constructor con = c.getDeclaredConstructor();
        System.out.println(con.getName()+"4===>"+con.getParameterCount());

        //定位某个有参构造器
        Constructor con2 = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(con2.getName()+"5===>"+con2.getParameterCount());
    }
  • 获取构造器的作用依旧是初始化一个对象返回
  @Test
    public void getDeclaredConstructor() throws Exception{
        //o1.获取类对象
        Class c = Student.class;
        //o2.提取类中的单个构造器对象
        Constructor con = c.getDeclaredConstructor();
        System.out.println(con.getName()+"4===>"+con.getParameterCount());

        //如果遇到私有的构造器，可以暴力反射
        con.setAccessible(true);  //权限被打开

        Student s = (Student) con.newInstance();
        System.out.println(s);

        //定位某个有参构造器
        Constructor con2 = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(con2.getName()+"5===>"+con2.getParameterCount());

        Student s1 = (Student) con2.newInstance("sun",100);
        System.out.println(s1);
   }
  • 如果是非public的构造器，需要打开权限，然后再创建对象
    setAccessible(boolean)
4.反射获取成员变量对象
  • 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象
  • Class类中用于获取成员变量的方法

在这里插入图片描述

@Test
    public void getDeclaredFields(){
        //a.定位Class对象
        Class c = Student.class;
        //b.定位全部成员变量
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + "==>" + field.getType());
        }
    }

    /**
     * 2.获取某个成员变量对象
     */
    @Test
    public void getDeclaredField() throws Exception{
        //a.定位Class对象
        Class c = Student.class;
        //b.定位某个成员变量
        Field f = c.getDeclaredField("age");
        System.out.println(f.getName() + "==>" + f.getType());
    }
  • 成员变量赋值、取值
 @Test
    public void setField() throws Exception{
        Class c = Student.class;
        Field ageF = c.getDeclaredField("age");

        ageF.setAccessible(true);
        //赋值
        Student s = new Student();
        ageF.set(s,18);
        System.out.println(s);
        //取值
        int age = (int)ageF.get(s);
        System.out.println(age);
    }
5.反射获取方法对象
  • 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象

在这里插入图片描述

  • Object invoke(Object obj, Object… args) ----在某个对象中出发该方法执行
  • 非public的成员方法，需要暴力打开权限
6.反射的作用-绕过编译阶段为集合添加数据
  • 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的
  • 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList，泛型相当于被擦除了
7.反射的作用-通用框架的底层原理

三、注解

（1）注解概述、作用

  • Java注解又称Java标注，是JDK5引入的一种注解机制
  • Java语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注

（2）注解的作用

  • 对Java中类、方法、成员变量做标记，然后进行特殊处理
  • eg. @Test方法就可以被当做测试方法执行

（3）自定义注解—格式

public @interface 注解名称{
      public 属性类型 属性名() default 默认值;
}
  • 特殊属性：
    value属性：如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写；但是有多个属性，且多个属性没有默认值，那么value是不能省略的

（4）元注解

  • 就是注解注解的注解
  • 元注解常见的有两个
    a. @Target:约束自定义注解只能在哪些地方使用
    b. @Retention:申明注解的生命周期
    在这里插入图片描述
    （5）注解解析
  • 判断是否存在注解，存在注解就解析出内容
  • 与注解解析相关的接口：
    Annotation：注解的顶级接口，注解都是Annotation类型的对象
    AnnotatedElement:定义与注解解析相关的解析方法
    所有的类成分Class、Method、Field、Constructor，都实现了AnnotatedElement接口，都拥有解析注解的能力。
    在这里插入图片描述
/**
 * 完成注解的解析
 */
public class Demo2 {
    @Test
    public void parseClass(){
        //先得到类对象
        Class c = BookStore.class;
        //判断类上是否存在注解
        if(c.isAnnotationPresent(book.class)){
            //直接获取该注解对象
            book bk = (book)c.getDeclaredAnnotation(d4_annotation.book.class);
            System.out.println(bk.value());
            System.out.println(bk.price());
            System.out.println(Arrays.toString(bk.author()));
        }
    }

    @Test
    public void parseMethod() throws Exception{
        //先得到类对象
        Class c = BookStore.class;
        Method m = c.getDeclaredMethod("test");
        //判断类上是否存在注解
        if(m.isAnnotationPresent(book.class)){
            //直接获取该注解对象
            book bk = (book)m.getDeclaredAnnotation(d4_annotation.book.class);
            System.out.println(bk.value());
            System.out.println(bk.price());
            System.out.println(Arrays.toString(bk.author()));
        }
    }
}


@book(value = "《某某》",price = 99.9,author = {"江添","盛旺"})
class BookStore{
    @book(value = "《不见上仙三百年》",price = 199.9,author = {"木苏里","魔道"})
    public void test(){
    }
}

@Target({ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段也不消失
public @interface Mytest {

}

（6）注解的应用场景：junit框架

四、动态代理

（1）动态代理概述、入门

什么是代理？
某些场景下对象会找一个代理对象，来辅助自己完成一些工作

//Test
//目标：学习开发出一个动态代理的对象出来，理解动态代理的执行流程
    //1.创建一个对象，对象的类必须实现接口
    public static void main(String[] args) {
        Star s = new Star("杨超越");
        //生成s的代理对象
        Skill s2 = StarAgent.getProxy(s);
        s2.jump();
        s2.sing();
    }

//StarAgent
   public static Skill getProxy(Star obj){
        //为s生成一个代理对象
        return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("收定金");
                        //触发对象真正去干活
                        //method 正在调用的方法 args 代表这个方法的参数
                        Object rs = method.invoke(obj,args);
                        System.out.println("收尾款");
                        return rs;
                    }
                });

    }

public class Star implements Skill {
    private String name;

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


    @Override
    public void jump() {
        System.out.println(name + "开始跳舞");
    }

    @Override
    public void sing() {
        System.out.println(name + "开始唱歌");
    }
}

//接口
public interface Skill {
    void jump();
    void sing();
}
（2）动态代理应用案例：做性能分析、代理的好处小结
public class Test {
    public static void main(String[] args) {
        UserService userService = ProxyUtil.getProxy(new UserServiceimpl());
        System.out.println(userService.login("admin", "123456"));
        System.out.println(userService.selectUsers());
        userService.deleteUser();
    }
}

public class UserServiceimpl implements UserService {

    @Override
    public String login(String loginName, String passWord) {
       String rs = "登录名称和密码错误";
       if("admin".equals(loginName) && "123456".equals(passWord)){
           rs = "登录成功";
       }
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
       return rs;
    }

    @Override
    public void deleteUser() {
        try {
            System.out.println("您正在删除用户数据");
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public String selectUsers() {
        String rs = "查询了10000个用户数据";
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rs;
    }
}

public interface UserService {
    String login(String loginName, String passWord);
    void deleteUser();
    String selectUsers();
}

public class ProxyUtil {
    /**
     * 通过一个静态方法，为用户业务对象返回一个代理对象
     */
    public static UserService getProxy(UserService obj){
        return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long starTime = System.currentTimeMillis();
                        //真正触发对象的行为执行
                        Object rs = method.invoke(obj,args);
                        long endTime = System.currentTimeMillis();
                        System.out.println( method.getName() +"方法耗时：" + (endTime-starTime)/1000.0 +"s");
                        return rs;
                    }
                });
    }
}
枯芥子
关注
专栏目录
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable
一个恶意卖萌的博客
05-09 3314
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable 问题描述： Arrays.sort不能对自定义对象进行排序。现希望对自定义的PersonSortable类的对象，使用Arrays.sort进行排序。 1.编写PersonSortable类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toStr...
面向对象进阶，面向对象进阶
09-10
本节我们将深入探讨面向对象的进阶概念，包括封装、继承、多态以及接口等核心原则，帮助开发者更好地理解和运用这一强大的编程范式。 1. 封装：封装是面向对象的基础，它将数据和操作数据的方法绑定在一起，形成一...
Java面向对象（进阶）
Ironsb的博客
10-24 247
Java面向对象进阶知识
Python基础之面向对象进阶
07-20 251
Python基础之面向对象进阶一：面向对象之组合二：单例设计模式2.1 __ new__方法 一：面向对象之组合 组合即在类中封装另一个类的对象。 组合的意义：让类的对象与另一个类的对象产生关系，类与类之间产生关系。 让两个类之间产生关系：一是继承，二是组合。 class GameRole: def __init__(self, nickname, ad, hp): self.nickname = nickname self.ad = ad # 血值
面向对象进阶
queenbao621的博客
06-15 1249
1、比较成员变量和局部变量的区别 成员变量也称为属性、 Java中的成员变量分为类属性和实例属性两种，定义属性时没有static修饰符修饰的就是实例属性、
06面向对象进阶
Yang_Jin_的博客
04-01 276
面向对象进阶 JVM内存的分配 编译器将.java文件转化为.class文件 .class文件被交给类加载器（三种）----在内存中分配空间 JVM（java虚拟机）会将内存分为5块： 栈：java栈的区域比较小，空间1M，特点：（存取数据）速度非常快，在栈里执行的基本上都是快速任务，存基本数据类型和对象的引用 堆：new出来的对象都存放在堆里面，堆里面的每一个对象都会产生一个唯一的地址，内存地...
java面向对象进阶
xiaomuwuya的博客
06-10 1165
java的面向对象指的是将我们的现实当中的事物抽象成一段java代码来描述，那现实当中的实体对象具有哪些方面是需要用代码的描述？ 任何一个类需要从两方面描述 1、特征、属性 —-一定时间范围内不会变化 2、行为、功能、方法 — 该类事物可以发出的动作 在java里面概括为 属性 和 方法(函数) ...
JAVA面向对象进阶
weixin_58835941的博客
06-15 1367
一：成员变量 在java中，变量可以分为成员变量和局部变量，成员变量是定义在类范围内的变量，局部变量是定义在方法中的变量。
面向对象进阶笔记
lzy520o的博客
05-03 171
面向对象进阶 封装private 封装的意义在于保护或防止代码（数据）被无意中破坏。 保护成员属性，不让类以外的程序直接访问和修改； 封装的原则：隐藏对象的属性和实现细节，仅对外公开访问方法，并控制访问级别。 在开发中为了避免逻辑错误，建议对所有属性进行封装，为其提供setter和getter方法进行设置和取得 操作。 this关键字 表示当前对象 能完成的操作： 调用类中的属性 调用类中的方法或...
php 面向对象进阶,PHP面向对象的进阶学习
weixin_39625468的博客
03-23 53
PHP面向对象的进阶学习1、接口不能被实例化，接口中所有的方法都不能有主体；2、一个类可以实现多个接口，以逗号(，)分隔 class demo implements if1,if2,if3{}3、接口中可以有属性，但必须是常量，常量不可以有修饰符(默认是public修饰符)如：interface iUsb{const A=90;}echo iUsb::A;4、接口中的方法都必须是public的，默...
85_面向对象进阶
onepiSya
09-17 140
文章目录89.面向对象进阶面向对象三大特征介绍封装（隐藏）继承多态 89.面向对象进阶 面向对象三大特征介绍 Python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。 封装（隐藏）   隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只 对外暴露“相关调用方法”。   通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python 追求简洁的 语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。 继承   继承可以让子类具有
Python面向对象进阶学习
09-19
### Python面向对象进阶学习知识点 #### 一、前言 在初步掌握了Python面向对象的基础概念后，进阶的学习显得尤为重要。本篇文章旨在为读者提供更深入的理解与实践指南，帮助大家更好地掌握Python面向对象编程的...
python进阶_浅谈面向对象进阶
09-21
### Python进阶之面向对象进阶 面向对象编程（Object-Oriented Programming，简称OOP）是现代软件开发中一种非常重要的编程范式。Python作为一种支持面向对象特性的语言，其面向对象编程功能强大且灵活。本文将深入...
python面向对象进阶之路
12-21
众所周知，python是门面向对象编程语言，面向对象是一个程序设计和编程思想，即一切皆为对象。 面向对象 面向对象三要素：封装，继承， 多态 封装？ 把一致的行为或者公共的部分封装成一个类或者方法。 比如把一定...
Python面向对象进阶教程,Python面向对象进阶知识笔记.doc
10-01
本文将深入探讨Python面向对象编程的进阶知识，包括类方法、静态方法、`__new__`和`__init__`方法以及单例模式。 1. **类方法**： 类方法是通过装饰器`@classmethod`标识的方法，它们的第一个参数通常是`cls`，...
JUnit 5 详解
Flying_Fish_roe的博客
09-12 741
JUnit 5 是一个强大且灵活的测试框架，它通过模块化设计、扩展性增强和强大的新特性（如动态测试、参数化测试等）满足了现代 Java 开发的需求。无论是编写单元测试、集成测试还是其他类型的测试，JUnit 5 都提供了丰富的工具和支持。JUnit 5 在设计上有别于之前的版本，并引入了全新的架构体系，使其适应现代 Java 开发的需求。这种模块化的设计让 JUnit 5 非常灵活，支持多种测试引擎共存，还能与其他测试框架（如 Spock、Cucumber）集成。断言是验证测试结果的核心。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1118
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 884
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Java面向对象进阶：类的继承与访问控制
"面向对象进阶的Java基础知识，包括访问控制、super与this、类的继承、方法的重写与重载等内容。" 在Java编程语言中，面向对象编程（Object-Oriented Programming, OOP）是核心特性之一，它允许我们以更符合现实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值