Java-Java基础学习（5）-注解和反射以及类的加载过程分析

JasonHuan1123

已于 2024-03-23 13:00:52 修改

阅读量1.2k

点赞数 20

分类专栏： # 编程语言文章标签： java 学习 visual studio code intellij idea

于 2024-03-22 23:27:21 首次发布

本文链接：https://blog.csdn.net/donghuandong/article/details/136954393

版权

编程语言专栏收录该内容

5 篇文章 0 订阅

订阅专栏

4.1 注解的理解

Annotation是从JDK5.0开始引入的新技术
Annotation的作用
- 不是程序本身，可以对程序作出解释（这点和注释comment没什么区别）；
- 可以被其他程序（比如：编译器等）读取；
Annotation的格式
- 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”).
Annotation在哪里使用
- 可以附加在package、class、method、field等上面；
- 相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。
元注解
- 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，它们被用来提供对其他annotation类型作说明；
- 这些类型和他们所支持的类在java.lang.annotation包中可以找到；
  - @Target：用于描述注解的使用范围（即：被描述的注解可以使用在什么地方）；
  - @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE < CLASS <RUNTIME）
  - @Document：说明该注解将被包含在javadoc中
  - @Inherited：说明子类可以继承父类中的该注解。
Java 注解（Annotations）是 JDK 5.0 引入的一种元素，它可以用于创建元数据，被 Java 编译器用来生成类文件、接口文件或者其他的文件。注解不会直接影响代码的语义，但可以用来被编译器或其他的工具进行解析和使用，从而生成额外的代码或执行某些操作。

4.2 反射

1. 动态语言与静态语言

动态语言，是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗讲就是在运行时代码可以根据某些条件改变自身结构。例如：Object-c、c#、JavaScript、PHP、Python等
静态语言，运行时结构不可变的语言就是静态语言。例如：Java、c、c++等。Java可以称为“准动态语言”，由于我们可以利用反射机制获得类似动态语言的特性。

2. Reflection 反射

Reflection（反射）是java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
```
例如： Class c = Class.forName("java.lang.String");
```
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以称之为：反射。

正常方式：

（1）引入需要的“包类”名称；（2）通过new实例化；（3）取得实例化对象。

反射方式：

（1）实例化对象；（2）getClass方法；（3）得到完整的“包类”名称

3. Java反射机制提供的功能

在运行时，判断任意一个对象所属的类；
在运行时，构造任意一个类的对象；
在运行时，判断任意一个类所具有的成员变量和方法；
在运行时，获取泛型信息；
在运行时，调用任意一个对象的成员变量和方法；
在运行时，处理注解；
生成动态代理，AOP中大量用到

4. Class类

Class本身也是一个类；
Class对象只能由系统建立对象；
一个加载的类在JVM中只会有一个Class实例；
一个Class对象对应的是一个加载到JVM中的一个class文件；
每个类的实例都会记得自己是由哪个Class实例所生成；
通过Class可以完整地得到一个类中的所有被加载的结构；
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

5. 得到Class实例的几种方式

方式一：若已知某个类的实例，调用该实例的getClass()方法获取Class对象
```
Person person = new Student(); 
Class c1 = person.getClass();
```
方式二：通过ForName获取，若已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
```
 Class c2 = Class.forName("com.hzs.basic.reflection.Student");
```
方式三：若已知具体的类，通过类的class属性获取，通过类名.class获取，该方法最为安全可靠，程序性能最高。
```
Class c5 = Student.class;
```
方式四：基本内置类型的Type属性获取
```
Class c6 = Integer.TYPE;
```
还可以通过ClassLoader获取

获取父类对象

 Class superclass = c1.getSuperclass(); //父类是Person
 System.out.println("superclass:"+superclass.hashCode());

 Class personClass = Person.class;
 System.out.println("personClass:"+personClass.hashCode());
输出：
superclass:1956725890
personClass:1956725890

6. 所有类型的Class对象

        Class c1 = Object.class; // 类
        Class c2 = Comparable.class; //接口
        Class c3 = String[].class; //一维数组
        Class c4 = int[][].class; // 二维数组
        Class c5  = Override.class; //注解
        Class c6 = ElementType.class;// 枚举类型
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;// void
        Class c9 = Class.class;//Class

输出：
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class

7. Java内存分析

堆
- 存放new的对象和数组；
- 可以被所有的线程共享，不会存放别的对象引用
栈
- 存放基本变量类型（会包含这个基本类型的具体数值）；
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量

8. 类的加载与ClassLoader的理解

加载
- 将class文件字节码内容加载到内存中；
- 并将这些静态数据转换成方法区的运行时数据结构；
- 然后，生成一个代表这个类的java.lang.Class对象
链接：将Java的二进制代码合并到JVM的运行状态之中的过程
- 验证：确保加载的类信息符合JVM规范，没有安全方面问题；
- 准备：正式为类变量（static）分配内存并设置变量默认初始值的阶段，这些内存都将在方法区中进行分配；
- 解析：虚拟机常量池内的符合引用（常量名）替换为直接引用（地址）的过程。
初始化
- 执行类构造器()方法的过程。类构造器方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化；
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

9. 分析类的初始化

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类；
- new 一个类的对象；
- 调用类的静态成员（除了final常量）和静态方法；
- 使用java.lang.reflect包的方法对类进行反射调用；
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化；
- 通过数组定义类引用，不会触发此类的初始化；
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

10. 类加载器的作用

* 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法去的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象。作为方法区中类数据的访问入口；
* 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

11. 类加载器

* （1）自定义类加载器

* （2）System Classloader：

  > 系统类加载器：
  >
  >        负责java-classpath 或-D java.class.path 所指的目录下的类与jar包装入工作，是最常用的加载器

* （3）Extension Classloader：

  >扩展类加载器：
  >
  >        负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库

* （4）Bootstap Classloader：

  >引导类加载器：
  >
  >       用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。

12. 加载器测试

```java
        // 获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        // 父加载器，扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        // parent的parent，根加载器（c/c++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

输出：
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@74a14482
null
```

4.3 注解的应用场景总结和代码举例

以下是 Java 注解的一些常见应用场景和代码举例：

1. 编译检查

注解可以用于编译时检查代码是否符合某些规范。例如，可以定义一个注解来标记某个方法必须是线程安全的。

```java
@interface ThreadSafe {  
}  
  
public class MyClass {  
    @ThreadSafe  
    public void myMethod() {  
        // ...  
    }  
}
```

在这个例子中，`@ThreadSafe` 注解用于标记 `myMethod` 方法应该是线程安全的。虽然这个注解本身不会做任何事情，但它可以被其他工具（如静态代码分析器）用来检查代码是否满足线程安全的条件。

2. 框架配置

许多框架（如 Spring、Hibernate 等）都使用注解来简化配置。例如，在 Spring 中，可以使用 `@Autowired` 注解来自动装配 Bean。

```java
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyComponent {  
    private final MyService myService;  
  
    @Autowired  
    public MyComponent(MyService myService) {  
        this.myService = myService;  
    }  
}
```

在这个例子中，`@Component` 注解用于标记 `MyComponent` 类是一个 Spring 组件，而 `@Autowired` 注解则用于自动装配 `MyService` 类型的 Bean。

3. 测试

注解也可以用于测试，例如 JUnit 测试框架就大量使用了注解。

```java
import org.junit.jupiter.api.Test;  
import static org.junit.jupiter.api.Assertions.*;  
  
public class MyTests {  
    @Test  
    public void testAddition() {  
        int result = 2 + 2;  
        assertEquals(4, result);  
    }  
}
```

在这个例子中，`@Test` 注解用于标记 `testAddition` 方法是一个测试方法。JUnit 测试框架会识别并运行这个方法。

4. 创建自定义注解

你还可以创建自定义注解来满足特定的需求。例如，你可以创建一个注解来记录某个方法或类的创建者和创建时间。

```java
import java.lang.annotation.*;  
  
@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.METHOD)  
public @interface CreatedBy {  
    String value();  
}  
  
public class MyClass {  
    @CreatedBy("Jason Huan")  
    public void myMethod() {  
        // ...  
    }  
}
```

在这个例子中，`@CreatedBy` 是一个自定义注解，用于记录方法的创建者。你可以使用反射来在运行时读取这个注解的值。

4.4 反射的应用场景总结和代码举例

Java反射（Reflection）是Java语言的一个强大特性，它允许程序在运行时检查类、接口、字段和方法的信息，并且可以动态地创建和调用对象。反射在很多场景中都有应用，包括但不限于框架设计、测试、序列化、ORM框架等。

下面是一些Java反射的应用场景和代码举例：

1. 动态创建对象

你可以使用反射来动态地创建对象，而无需提前知道对象的类。

```java
Class<?> clazz = Class.forName("java.util.ArrayList");  
Object obj = clazz.newInstance(); // 假设ArrayList有一个无参构造器
```

2. 调用方法

你可以使用反射来调用一个对象的方法。

```java
Class<?> stringClass = "Hello".getClass();  
Method nameMethod = stringClass.getMethod("toUpperCase");  
String upperCaseString = (String) nameMethod.invoke("Hello");  
System.out.println(upperCaseString); // 输出: HELLO
```

3. 访问字段

你可以使用反射来获取或设置一个对象的字段值。

```java
Class<?> personClass = Person.class;  
Person person = new Person();  
Field nameField = personClass.getDeclaredField("name");  
nameField.setAccessible(true); // 如果字段是私有的，需要设置可访问  
nameField.set(person, "Alice"); // 设置字段值  
System.out.println(nameField.get(person)); // 输出: Alice
```

其中`Person`类可能如下：

```java
public class Person {  
    private String name;  
    // 构造器、getter和setter省略  
}
```

4. 获取注解信息

你可以使用反射来读取运行时类的注解信息。

```java
@Retention(RetentionPolicy.RUNTIME)  
@interface MyAnnotation {  
    String value();  
}  
  
@MyAnnotation(value = "example")  
public class MyClass {  
    // ...  
}  
  
// 获取注解信息  
Class<?> myClass = MyClass.class;  
if (myClass.isAnnotationPresent(MyAnnotation.class)) {  
    MyAnnotation annotation = myClass.getAnnotation(MyAnnotation.class);  
    System.out.println(annotation.value()); // 输出: example  
}
```

5. 框架设计

反射在框架设计中特别有用，因为它允许框架在运行时动态地处理类和对象，而无需在编译时知道所有的细节。例如，Spring框架使用反射来创建和注入bean，Hibernate使用反射来处理ORM映射等。

6. 测试

在单元测试中，反射可以用来动态地创建和调用被测试的代码，或者用来检查类的内部状态。

这只是Java反射的一些应用场景和简单的代码示例。实际上，反射在Java中的用途非常广泛，但也需要谨慎使用，因为它可能会破坏封装性，降低代码性能，并可能导致安全问题。在大多数应用中，应该优先使用正常的Java编程技术，只在必要时使用反射。

4.5 注解和反射的经典面试题

以下是一些关于Java注解和反射的经典面试题及其可能的答案：

1.Java注解面试题

请解释什么是Java注解？

Java注解是一种元数据，它可以用于向Java源代码中的程序元素（类、方法、字段等）添加额外的信息。这些信息不会对程序的实际执行产生影响，但可以被编译器、工具和框架用来进行静态检查和生成额外的代码。

请列举一些常见的Java注解及其用途。

@Override：表示当前方法覆盖了父类中的方法。
@Deprecated：表示某个类或方法已过时，不建议使用。
@SuppressWarnings：抑制编译器警告。
@Test（JUnit）：标记一个方法为测试方法。
@Autowired（Spring）：自动装配Bean。

请解释元注解的作用。

元注解是用于标记其他注解的注解。它们可以用来定义新的注解或对现有注解进行解释和限制。一些常见的元注解包括：
- @Retention：用于指定注解的生命周期。
- @Target：用于指定注解的作用目标（类、方法、字段等）。
- @Documented：用于指定注解是否包含在Javadoc文档中。
- @Inherited：用于指定注解是否可以被继承。

请解释自定义注解的步骤。

自定义注解的步骤通常包括：
- 使用@interface关键字定义注解。
- 使用元注解（如@Retention和@Target）来指定注解的属性和行为。
- 在需要的地方使用自定义注解，并可能通过反射读取和处理这些注解。

2.Java反射面试题

请解释什么是Java反射？

Java反射是指在运行时对类的信息（如类的属性、方法、构造函数等）进行动态获取和操作的能力。通过反射，我们可以在运行时动态地创建对象、调用方法、访问和修改字段等。

反射的核心是什么？

反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

请列举几个Java反射的常见应用场景。

框架设计：如Spring、Hibernate等框架利用反射实现依赖注入和ORM映射。
动态代理：通过反射动态地创建代理对象，实现AOP（面向切面编程）。
测试：利用反射编写更灵活的测试用例，动态地调用被测试类的方法。
插件机制：允许第三方插件动态地加载到系统中，并调用插件提供的方法。

使用反射调用方法时需要注意什么？

使用反射调用方法时需要注意方法的访问权限，如果方法是私有的，需要设置setAccessible(true)来解除访问限制。此外，还需要注意方法的参数类型和数量，以确保正确调用方法。

JasonHuan1123

关注

20
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java-Java基础学习（5）-注解和反射以及类的加载过程分析

本文介绍了Java基础中的注解和反射以及类的加载过程。注解用于为代码添加元数据，可自定义并用于编译时检查、框架配置等。反射则允许程序在运行时检查类、接口、字段和方法的信息，并动态调用它们。文章详细阐述了反射的机制，包括获取Class实例的多种方式。此外，还分析了Java内存结构，解释了类的加载过程与ClassLoader的作用。最后，通过应用场景对比总结了注解与反射的优劣，并收集整理了相关面试题及测试代码，帮助读者深化理解并提升实战能力。
复制链接

扫一扫