Java高级技术

已于 2025-07-24 11:11:26 修改
阅读量461 收藏 6
点赞数 12
CC 4.0 BY-SA版权
文章标签： java 开发语言
于 2025-07-24 11:11:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sjdjjdkd/article/details/149530980

目录

1.单元测试

2.反射

2.1 认识反射、获取类

2.2 获取类中的成分，并对其进行操作

2.3 反射的作用

3.注解

3.1 概述、自定义注解

3.2 元注解

 3.3 注解的解析

 3.4 注解的应用场景

4.动态代理

4.1什么是代理？

4.2 动态代理解决实际问题

1.单元测试

/**
 * 字符串工具类
 */
public class StringUtil {
    public static void printNumber(String name){
        if(name == null){
            System.out.println("参数不能为null");
            return;
        }
        System.out.println("名字长度是：" + name.length());
    }

    /**
     * 求字符串的最大索引
     */
    public static int getMaxIndex(String data){
        if(data == null ||  "".equals(data)) {
            return -1;
        }
        return data.length() -1;
    }
}

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

    @Test
    public void testGetMaxIndex(){
//        System.out.println(StringUtil.getMaxIndex(null));
//        System.out.println(StringUtil.getMaxIndex(""));
//        System.out.println(StringUtil.getMaxIndex("admin"));
        // 断言：预言。
        int i1 = StringUtil.getMaxIndex(null);
        //public static void assertEquals(String message, long expected, long actual)
        Assert.assertEquals("null测试失败!", -1, i1);

        int i2 = StringUtil.getMaxIndex("");
        Assert.assertEquals("空字符串测试失败!", -1, i2);

        int i3 = StringUtil.getMaxIndex("admin");
        Assert.assertEquals("admin测试失败!", 4, i3);

        System.out.println("测试通过！");
    }

JUnit单元测试的实现过程是什么样的？

  •  必须导入Junit框架的jar包
  • 定义的测试方法必须是无参数返回值，且公开的方法
  • 测试方法使用@Test注解标记

JUnit测试某个方法，测试全部方法怎么处理？成功的标志是什么？

  • 测试某个方法直接右键该方法启动测试
  • 测试全部方法，可以选择类或者模块启动
  • 红色失败，绿色通过

2.反射

2.1 认识反射、获取类

 

public class Student {
    private String name;
    private int age;
    private char sex;
    private double height;
    private String hobby;

    public Student() {
    }

    public Student(String name, int age, char sex, double height, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.hobby = hobby;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

package com.itheima.d2_reflect;

/**
 * 目标：获取Class对象。
 */
public class Test1Class {
    public static void main(String[] args) throws Exception {
        // 目标：反射第一步：获取Class对象。
        // 1、方式一：类名.class
        Class c1 = Student.class;
        System.out.println(c1);

        // 2、方式二：Class.forName(全类名)
        Class c2 = Class.forName("com.itheima.d2_reflect.Student");
        System.out.println(c2);

        // 3、方式三：对象.getClass();
        Student s1 = new Student();
        Class c3 = s1.getClass();
        System.out.println(c3);

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

2.2 获取类中的成分，并对其进行操作

package com.itheima.d2_reflect;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;
    private String hobby;

    public Cat() {
        System.out.println("无参数构造器执行了~~");
    }

    private Cat(String name) {
        System.out.println("一个参数构造器执行了~~");
        this.name = name;
    }

    public Cat(String name, int age) {
        System.out.println("有参数构造器执行了~~");
        this.name = name;
        this.age = age;
    }

    public void run() {
        System.out.println("🐱跑的贼快~~");
    }

    private void eat() {
        System.out.println("🐱爱吃猫粮~");
    }

    public String eat(String name) {
        return "🐱最爱吃:" + name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", hobby='" + hobby + '\'' +
                '}';
    }
}
package com.itheima.d2_reflect;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 目标：掌握获取类的构造器，并对其进行操作。
 */
public class Test2Constructor {

    @Test
    public void getClassInfo(){
        // 1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        System.out.println(c.getName());//类名的全类名 com.itheima.d2_reflect.Cat
        System.out.println(c.getSimpleName());//类名 Cat
    }

    @Test
    public void getConstructorInfo() throws Exception {
        //目标：获取类的构造器对象并对其进行操作
        // 1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 2、获取类的全部构造器
        // Constructor[] constructors = c.getConstructors(); // 只能拿public的
        Constructor[] cons = c.getDeclaredConstructors(); // 存在即可拿
        // 3、遍历构造器
        for (Constructor con : cons) {
            System.out.println(con.getName() + " ===> " + con.getParameterCount());
        }
        //4.获取单个构造器
        Constructor con = c.getDeclaredConstructor();//无参数构造器
        System.out.println(con.getName() + " ===> " + con.getParameterCount());

        Constructor con2 = c.getDeclaredConstructor(String.class, int.class);//带参数构造器
        System.out.println(con2.getName() + " ===> " + con2.getParameterCount());

        //5.获取构造器的作用依然是创建对象：创建对象。
        //暴力反射：暴力反射可以访问私有的构造器、方法、属性
        con.setAccessible(true);//绕过访问权限，直接访问！临时攻破权限
        Cat cat = (Cat) con.newInstance();//需要强转
        System.out.println(cat);

        Cat tom = (Cat)con2.newInstance("Tom", 5);
        System.out.println(tom);
    }

    //获取类的成员变量对象并对其进行操作
    @Test
    public void getFieldInfo() throws Exception {
        //目标：获取类的成员变量对象并对其进行操作
        // 1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        //2.获取所有成员变量对象
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getType() + " ===> " + field.getName());
        }
        //3.获取某个成员变量对象
        Field fname = c.getDeclaredField("hobby");
        System.out.println(fname.getType() + " ===> " + fname.getName());

        //4.获取成员变量的目的：取值和赋值。
        Cat cat = new Cat("泰迪",3);
        fname.setAccessible(true);//绕过访问权限，直接访问！临时攻破权限
        fname.set(cat,"社交");//hobby是私有的，所以需要暴力反射才能访问
        System.out.println(cat);

        String hobby = (String) fname.get(cat);//cat.getHobby()作用相同
        System.out.println(hobby);
    }

    //获取类的成员方法对象并对其进行操作
    @Test
    public void getMethodInfo() throws Exception {
        //目标：获取类的成员方法对象并对其进行操作
        // 1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        //2.获取所有成员方法对象
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getReturnType() + " ===> " + method.getName() + " " + method.getParameterCount());
        }
        //3.获取某个成员方法对象
        Method eat = c.getDeclaredMethod("eat");//获取无参数的eat方法
        System.out.println(eat.getReturnType() + " ===> " + eat.getName() + " " + eat.getParameterCount());
        //4.获取带参数的成员方法对象
        Method eat2 = c.getDeclaredMethod("eat", String.class);
        System.out.println(eat2.getReturnType() + " ===> " + eat2.getName() + " " + eat2.getParameterCount());

        //5.获取成员方法的目的：执行它！
        Cat cat = new Cat("Tom",5);
        eat.setAccessible(true);//暴力反射
        Object rs =eat.invoke(cat);//唤醒对象cat的eat方法执行，相当于cat.eat();
        System.out.println(rs);//null

        Object rs2 = eat2.invoke(cat,"牛肉");//唤醒对象cat的带String参eat方法执行，相当于cat.eat("牛肉");
        System.out.println(rs2);
    }
}

2.3 反射的作用

package com.itheima.d2_reflect;

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class SaveObjectFrame {
    //保存任意对象的静态方法
    public static void saveObject(Object obj) throws Exception {
        PrintStream ps = new PrintStream(new FileOutputStream("day14-" +
                "junit-reflect-annotation-proxy/src/obj2.txt",true));
        //obj可能是老师，学生，猫
        //只有反射可以知道对象有多少个字段
        //1.获取Class对象
        Class c = obj.getClass();
        String simpleName = c.getSimpleName();
        ps.println("==================" + simpleName + "====================");
        //2.获取Class对象的所有字段
        Field[] fields = c.getDeclaredFields();
        //3.遍历字段
        for (Field field : fields) {
            //4.获取字段的值
            //4.1 获取字段名称
            String fieldName = field.getName();
            //4.2 获取字段的值
            field.setAccessible(true);//暴力反射
            Object fieldValue = field.get(obj) + "";
            //5.打印到文件中去
            ps.println(fieldName + "=" + fieldValue);
        }
        ps.close();
    }
}

package com.itheima.d2_reflect;

/**
 * 目标：使用反射技术：设计一个保存对象的简易版框架。
 */
public class Test5Frame {
    public static void main(String[] args) throws Exception {
        //目标：搞清楚反射的应用：做框架的通用技术
        Cat c1 = new Cat("加菲", 3);
        // 需求：把任意对象的字段名和其对应的值等信息，保存到文件中去。
        SaveObjectFrame.saveObject(c1);
        //创建学生对象
        Student s1 = new Student("黑马吴彦祖", 45, '男', 185.3, "蓝球，冰球，阅读");
        SaveObjectFrame.saveObject(s1);
        //创建老师对象
        Teacher t1 = new Teacher("小王", 35, "打篮球", 5000, "JAVA班",'男',"屁股");
        SaveObjectFrame.saveObject(t1);

    }
}

3.注解

3.1 概述、自定义注解

package com.itheima.d3_annotation;
// 自定义注解
public @interface MyTest {
    String name();
    double money() default 100;
    String[] authors();
}

package com.itheima.d3_annotation;

public @interface MyTest2 {
    String value();//特殊属性，在使用时如果只有一个value属性，那么在使用时value可以省略
    int age() default 70;//有默认值可以不写
}

package com.itheima.d3_annotation;
@MyTest(name = "从入门到跑路", money = 9.9, authors = {"阿猫", "阿狗"})
//@MyTest2(value = "删除")
//@MyTest2(value = "删除", age = 23)
@MyTest2("删除")
public class AnnotationDemo1 {

    @MyTest(name = "从入门到跑路2", authors = {"阿猫2", "阿狗2"})
    private String name;

    @MyTest(name = "从入门到跑路", authors = {"阿猫", "阿狗"})
    public static void main(String[] args) {
        // 目标：掌握注解的使用。
        @MyTest(name = "从入门到跑路3", authors = {"阿猫3", "阿狗3"})
        int age = 12;
    }
}

3.2 元注解

package com.itheima.d3_annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE}) // 声明注解的范围，只能注解方法和类
@Retention(RetentionPolicy.RUNTIME) // 这个注解始终活着
public @interface MyTest3 {
}

package com.itheima.d3_annotation;

@MyTest3
public class AnnotationDemo2 {

//    @MyTest3
    private String name;

//    @MyTest3
    public AnnotationDemo2(){
    }

    @MyTest3
    public void run(){

    }

    @MyTest3
    public static void main(String[] args) {
        // 目标：元注解
    }
}

 3.3 注解的解析

package com.itheima.d3_annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})// 声明注解的范围，只能注解方法和类
@Retention(RetentionPolicy.RUNTIME)// 这个注解始终活着
public @interface MyTest4 {
    String value();
    double aaa() default 100;
    String[] bbb();
}

 3.4 注解的应用场景

package com.itheima.d3_annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)// 声明注解的范围，只能注解方法
@Retention(RetentionPolicy.RUNTIME)// 这个注解始终活着
public @interface TestDlei {
    int value() default 1;
}

package com.itheima.d3_annotation;

import java.lang.reflect.Method;

public class AnnotationDemo4 {
    // 目标：搞清楚注解的应用场景：模拟junit框架。有TestDlei注解的方法，就执行这个方法。

    //测试方法：public 无参 无返回值
    public void test1() {
        System.out.println("===========test1=======");
    }

    @TestDlei
    public void test2() {
        System.out.println("===========test2=======");
    }

    public void test3() {
        System.out.println("===========test3=======");
    }

    @TestDlei(2)// value() = 2
    public void test4() {
        System.out.println("===========test4=======");
    }

    public static void main(String[] args) throws Exception {
        AnnotationDemo4 t = new AnnotationDemo4();
        //1.获取类对象
        // 有注解的跑他，没有注解的不跑他
        Class c = AnnotationDemo4.class;
        //2.获取所有方法
        Method[] methods = c.getDeclaredMethods();
        //3.遍历所有方法，判断方法上是否有注解
        for (Method method : methods) {
            // 4.判断这个方法上是否陈列了注解，是就跑
            if(method.isAnnotationPresent(TestDlei.class)){
                //获取到这个方法的注解
                TestDlei testDlei = method.getDeclaredAnnotation(TestDlei.class);
                int value = testDlei.value();
               //5.有就执行这个method方法
                for (int i = 0; i < value; i++) {
                    method.invoke(t);//invoke(Object obj, Object... args)必须用对象调用
                }
            }
        }
    }
}

4.动态代理

4.1什么是代理？

 4.2 动态代理解决实际问题

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    public static <T> T createProxy(T obj) {
        T proxy = (T) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader()
                , obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long startTime = System.currentTimeMillis();

                        // 真正走业务对象的方法
                        Object result = method.invoke(obj, args);

                        long end = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (end - startTime) / 1000.0);

                        return result;
                    }
                });
        return proxy;
    }
}

 可以把这个代理类改为泛型类，这样无论哪个接口的实现类都可以实现代理类想要实现的功能，如计算运行速度。

学Java的bb
关注
java高级技术人员要掌握哪些技术
g470641382的博客
02-24 1170
大厂对高级Java工程师的要求不仅是技术深度，更看重复杂场景的实战经验和技术判断力。建议通过开源项目贡献（如Apache项目）、技术博客输出、内部系统重构案例积累差异化竞争力。
java高级能力_java高级技术工程师该具备哪些能力？
weixin_36200739的博客
02-26 850
目前Java工程师的工资很不错，企业依旧愿意给Java人才很好的薪资待遇。不过从薪资上可以看出，目前Java初级工程师的平均薪资并不太高，这也说明企业目前需求的更多的是Java高端人才。那么java高级技术工程师该具备哪些能力?让我们继续往下了解吧!java高级技术java高级技术工程师该具备的能力：1、精通使用一种或两种框架。“框架都会有许多可重用的代码，良好的层次关系和业务控制逻辑，基于框架的...
Java高级技术梳理
时间静止
08-05 6754
背景 学习完java中高级阶段想对所学习到的知识进行梳理,借此回顾自己所学习到的知识 在这一阶段,首先是安装了虚拟机. 在安装虚拟机过后,学习了以后,就开始安装了jdk, tomcat, mysql . 在安装好这些环境后,我们算是吧虚拟机运行环境搭建完毕 搭建完毕之后,首先学习的了Maven, 用于对项目进行管理和构建 然后学习了zookeeper技术, 用于提供常用软件的集群管理 然后学习了D......
Java高级工程师必备技术栈
Mr_Gu的博客
03-07 5347
1 Java基础知识 包括异常处理、反射、注解、序列化等。 2 Java集合 数据集合框架以及继承关系。 3 JVM原理 包括JVM的架构、内存管理、垃圾回收、字节码、类加载机制等。 学会这本神书 《深入理解Java虚拟机》 你就可以入门JVM并且应付大部分人了。 4 Java多线程高并发 第一层学会Java线程基础知识以及常见的锁的用法 第二层去理解锁机制，线程的底层原理。 建议阅读 《Java并发编程的艺术》，阿里大牛的神作。 5 设计模式 23种设计模式，这个只需要你能够看出是哪种设计模式就好。如果要
java 高级应用都有哪些
王的专栏
11-04 502
java 高级用法
Java高级阶段技术总结
qq_55069674的博客
08-07 431
java技术总结
Java面试-高级篇
Wu 的小博文
06-11 5813
目录 1.Java中的内存管理和垃圾收集机制 1. 分析问题背景 1.1 Java的内存管理 1.2 Java的垃圾收集机制 2. 可能存在的考点 2.1 Java内存分区 2.2 垃圾收集算法 2.3 垃圾收集器的种类和选择 2.4 内存泄漏和内存溢出的区别与应对 3. 每个问题对应的回答方式 3.1 Java内存分区 3.2 垃圾收集算法 3.3 垃圾收集器的种类和选择 3.4 内存泄漏和内存溢出的区别与应对 2.解释Java中的强引用、软引用、弱引用和虚引用 1. 问题
高级JAVA开发 技术栈知识点总结
凌夏大叔的博客
05-16 3783
高级JAVA开发 面试知识点总结写在前面MQRedis分布式系统 和 Dubbo 写在前面 “金三银四”对于今年（2019）的互联网行业行情并不适用，面试遇到种种困难的同时也意识到个人技术水平不足，下面对近期学习做个总结，方便自己以后查阅，最好能帮助到和我一样是传统行业出身想跳槽到互联网行业的同学。以下知识点大多搜罗于大牛博客和“中华石杉”老师的视频，谢谢你们的文章和经验让我快速成长，谢谢！ 我会...
Java高级技术-单元测试
rch041126的博客
12-02 1059
单元测试 Junit单元测试框架 Junit单元测试-快速入门 方法类 测试类 Junit框架的基本注解
java高级技术经理面试题，编程入门，java常用算法面试题
2401_84102892的博客
04-05 1035
针对以上面试题，小编已经把面试题+答案整理好了。
Java+Java高级技术路线+Java学习必备
01-10
这份JAVA高级技术路线的思维导图是我根据多年的工作经验整理得到的 Java后端技术，技术路线就相当于是我们前进的梯子， 只有拥有了完整的学习路径，才能让我们少走弯路，才能让我们更快的成长。 可执行性强，方向...
Java后端技术-Java高级技术路线.xmind
07-05
作为一名Java后端开发者，一名高级技术人员，必须掌握的技术要点。 从新手进阶到高手的必经之路。此技术路线图，明确的指明了知识点和路线。 如果您没有方向，无从下手，不知道怎么提升，处于迷茫阶段，那么看它就对...
扩展：Java高级技术.zip
07-24
"扩展：Java高级技术.md"和"扩展：Java高级技术.pdf"可能是详细的教程或笔记，而"扩展：Java高级技术"可能是代码示例或其他资源，它们将帮助学习者巩固理论知识并实践应用。不断学习和实践，是成为一名优秀的Java ...
基于springboot的在线教育系统(源码+论文)
bronze_s的博客
07-21 2113
本文介绍了基于B/S架构的在线教育系统开发方案。系统采用Spring Boot框架和MySQL数据库，支持用户通过浏览器访问。文章详细阐述了系统结构设计，包括功能模块划分和数据库设计。数据库部分展示了地址、购物车、评论、讲师等核心表的字段结构，为系统实现提供了完整的数据模型基础。该系统设计实现了互联网环境下随时随地的教育服务访问需求。
Java从入门到精通！第十天，重点！(集合(二))
2301_80002260的博客
07-21 973
put 方法比较复杂，实现步骤如下：1. 先通过 hash 值计算出待插入的元素的 key 映射到哪个桶2. 如果桶上没有哈希冲突（哈希碰撞），即桶上没有元素，则直接插入3. 如果出现碰撞冲突，则需要处理冲突(1) 如果该桶使用红黑树处理冲突，则调用红黑树的方法插入(2) 否则采用传统的链式方法插入，如果链表的长度达到临界值（哈希表的容量大于 64 且链表节点个数大于 8），则把链表转换为红黑树4. 如果桶中存在重复的键，则为该键替换新值5. 如果 size 大于阈值，则进行扩容。
Java-80 深入浅出 RPC Dubbo 动态服务降级：从雪崩防护到配置中心秒级生效
永远好奇，无限进步！
07-23 1675
动态服务降级是一种在系统高压或异常情况下，保障核心业务可用性的关键策略。**它通过设定触发条件（如高CPU、响应慢、错误率高等）自动或手动屏蔽非核心功能、简化数据或直接返回默认值，防止系统雪崩。典型场景包括电商大促、秒杀活动或第三方服务异常等。Dubbo支持多种降级方式，如mock=force:return+null和mock=fail:return+null，并可通过配置中心实现动态控制与秒级生效。结合限流、熔断等机制，服务降级是构建高可用分布式系统的重要手段。
使用 Maven 的 `maven-assembly-plugin` 插件打包zip
weixin_42551921的博客
07-23 500
在pom.xml中配置来生成 ZIP 包。
java面向对象高级01——final关键字
最新发布
元气少女硕硕子的博客
07-24 87
final关键字用于定义不可变元素：修饰类时表示不可继承，修饰方法时表示不可重写。修饰变量时，基本类型值不可变，引用类型地址不可变但内容可变。static final修饰的成员变量称为常量，通常全大写命名，用于存储系统配置信息。
Java高级技术实现日志管理系统
Java高级技术通常涵盖了泛型、注解、反射、多线程和并发编程、Java I/O系统以及网络编程等内容。而“日志管理系统”是一个在软件开发和维护中至关重要的组件，它负责收集、存储、管理和展示应用程序运行时产生的各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值