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

最新推荐文章于 2024-08-21 12:46:24 发布
最新推荐文章于 2024-08-21 12:46:24 发布
阅读量1.2k 收藏 22
点赞数 20
分类专栏： JAVA基础篇 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44689664/article/details/135083181
版权

十九、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();
    }
}

测试类

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);

    }
}

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);

    }
}

2. 反射

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

java.lang.reflect

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

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

步骤：

  1. 加载类，获取类的字节码：Class对象
  2. 获取类的构造器：Constructor对象
  3. 获取类的成员变量：Field对象
  4. 获取类的成员方法：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

    }
}

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;
    }
}

获取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());
    }
}

作用：

初始化对象返回

@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());
}

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();
}

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

原理：

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

元注解：修饰注解的注解

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

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

注解的解析

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

如何解析注解：

要解析谁上面的注解，就要先拿到谁（要解析类上面的注解，应该先获取该类的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()));
        }
    }

}

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

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

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 + "正在跳舞！");
    }
}

想要代理的接口类Star

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

代理对象的类

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;

    }
}

主程序

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();
    }
}

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

小鱼0135
关注
专栏目录
java高级（javaAdv）
qq_56104948的博客
08-08 1078
HashSet(int capacity) 创建一个指定容量的集合对象，实际是创建了一个指定大小，加载 因子为0.75。方法判断的原理，大致为：将两个字符串保存到字符数组中，再对每个字符逐一比较， 如果全部一致则返回。但原始类型不属于对象，不满足面向对象的思想，但原始类型使用时无需创建对象，保存在栈中，效率更改。集合中保存的每个元素也称为节点，除首尾节点外，每个节点即保存了自己的数据，也保存了其前。如果在其中进行插入和删除的操作时，不影响其他元素的位置，只需要重新定义新节点的前后节点。...
Java 高级教程
04-05 1658
1. 数据结构 Java2中引入了一种新的框架-集合框架(Collection) 2. 集合接口 (1) 用得最多的是list接口和set接口。 (2) List 接口存储的是有序的，可以重复的元素。 Set 接口存储的是无序的，不重复的数据。 (3) List接口检索效率高，插入和删除效率低。 Set接口检索效率低，插入和删除效率高。 (4)Map.Entry: 描述Map中的一个元素（键/值对）。 3. 集合实现类 (1) ArrayList: 实现了List的接口, 随机访问和..
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（高级篇）
vincewm的博客
07-18 5295
本文是“Java学习路线”中Java基础知识的高级篇，主要对多线程和反射进行了深入浅出的介绍，在多线程部分，详细介绍了线程的概念、生命周期、多线程的线程安全、线程通信、线程同步，并对synchronized和Lock锁；反射部分对反射的特性、功能、优缺点、适用场景等进行了介绍。
JAVA高级阶段技术总结/个人总结
mussio404的博客
12-04 348
对Java高级阶段的习题的笼统整理，含课堂练习和企业面试。
如何深入学习Java：从基础到高级的系统指南
最新发布
大厂全栈码农
08-21 1万+
学习Java的过程是一个不断积累和深入的过程。通过系统地掌握Java的基本语法、面向对象编程、设计模式、框架与工具，再加上实际项目的实践，你将能够扎实地掌握这门编程语言，并在各类开发场景中得心应手。记住，编程能力的提升离不开实践，多写多练，不断总结经验，才是掌握Java的关键。
java高级
aiwujiangjie_job的博客
07-26 745
1、单列集合和双列集合       ——————————————————单列集合       Collection(最底层的父类)       List 有序，可重复       ArrayList 查询速度快，增删慢；底层用Object类的数组实现       LinkedList 查询速度块，增删块；       Vector 与ArrayList相同，操作效率低，线程安全(多个可
Java高级
weixin_44044929的博客
08-07 422
java高级知识点相关面试题，多线程、集合、IO、序列化、注解、反射。
JAVA基础篇——java logging
weixin_46872857的博客
06-11 4507
分
java软件开发——顶岗实习周记25篇.doc
06-28
- **技术深化**：进一步深化对Java及其相关技术的理解，如深入学习Spring框架等。 - **项目实战**：参与更复杂的项目开发，比如实现日志列表功能模块等。 - **自我挑战**：勇于接受新的挑战，比如独立完成某些功能...
Java语言程序设计——基础篇
10-17
根据提供的信息，“Java语言程序设计——基础篇”这本书主要针对初学者介绍了Java编程的基础知识。虽然部分内容并未给出具体章节或细节信息，但基于书名、描述及常见的Java基础教程内容，我们可以推测书中涵盖的主要...
java 高级功能
01-13
盖晗java中的IO XML 网络编程等主要高级性能
Java面试宝典基础篇1——设计模式和分布式事务.pdf
04-22
在Java开发领域，设计模式和分布式事务是面试中经常被提及的问题，是考察应聘者能力的重要方面。在面试中，面试官会问及应聘者对这些概念的理解、应用以及相关技术的掌握程度。 首先，设计模式是一套被广泛认识的、...
Java零基础——SpringSecurity篇
m0_47946173的博客
12-04 2078
Spring Security是一个能够为基于Spring的企业应用系统提供声明式（注解）的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
JAVA高级
JoshXz的博客
08-04 270
在这一周中，我们学习到的是JAVA的高级部分，主要是对IO流，多线程以及网络编程。 什么是流 流(IO),在计算机系统中，将不同的输入输出源统一抽象为流，流是一种实现数据交换技术的核心，比较常见的流的使用在于：文件操作，网络数据传输等；流由两大核心部分构成：1.Input(输入)，2.Output(输出)； 流的分类 1.按流向分为:输入和输出 2.按类型分为:字节和字符 3.按功能分...
java高级篇
qq_34064680的博客
04-23 2823
高级篇 复习：多线程、锁、枚举等待！ 多线程 线程-创建使用 //方式一 继承Thread class A extends Thread{ @Override public void run() { System.out.println("继承Thread 重写Run"); } } //方式二 实现 Runnable 接口类 class B implements Runnable{ @Override public void run() { .
Java-高级教程
鱼七
11-28 2098
Java-高级教程
java高级（零碎知识点）
weixin_60768886的博客
12-01 1200
Java高级的一些小知识点
Java学习之java高级特性
热门推荐
ling的博客
04-13 1万+
本部分内容主要有集合框架及泛型，实用类，输入和输出处理，注解与多线程，网络编程与XML技术。初次学习这部分会感觉很难，主要是概念难于理解，最好是多看看例子，多练习。下面是个人的总结 一、集合框架及泛型1、集合框架是一套性能优良、使用方便的接口和类（位于java.util包中）解决数组在存储上不能很好适应元素数量动态变化，查找效率低的缺陷集合接口： Map、Collection(子接口List、Se...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值