2021-10-01 annotation and reflection I

1, Annotation

1. Built in annotation

1.1 Override

Annotation for overriding superclass methods
 Can only be used for decorating methods
 Represents a method declaration intended to override another method in a superclass

1.2 Depecated

Not recommended
 Can be used to decorate methods, properties, and classes
 Indicates that programmers are not encouraged to use such elements

1.3 SuppressWarnings

Suppression warning
 Used to suppress compile time warnings
 Parameters are required when using

2. Meta annotation

2.1 function

Responsible for annotating other annotations, which are used to provide information about other annotations annotation Type for description
java Four criteria are defined meta-annotation type

2.2 including

  1. Target

    Describe the scope of use of annotations in value Description in
     That is, where the described annotation can be used, such as class, method, attribute, etc
  2. Retention

    At what level does the annotation information need to be saved to describe the declaration cycle of the annotation
     When is the annotation valid
  3. Documented

    The described annotation is generated in JAVADoc in
  4. Inherited

    A subclass can inherit the annotation of the parent class

2.3 define a note

//Indicates that the annotation can be used on methods and classes
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//Indicates that the annotation is valid at run time
@Retention(value = RetentionPolicy.RUNTIME)
//Indicates that the annotation is generated in javadoc
//Subclasses representing the class modified by the annotation can inherit the annotation
@interface MyAnnotation


3. User defined annotation

Annotation: @ interface is used to declare an annotation

Annotated parameters: parameter type + parameter name ();

@interface MyAnnotation
    String value();

2, Reflection

1. Static language and dynamic language

1.1 dynamic language

Is a kind of language whose structure can be changed at run time
 That is, the runtime code can change its structure according to some conditions

1.2 static language

A language whose runtime structure is immutable is a static language

java Not a dynamic language, but java It can be called quasi dynamic language, i.e java It has certain dynamics
 We can use reflection mechanism to obtain features similar to dynamic language

2. Introduction

The reflection mechanism allows programs to use Reflection API Get the internal information of any class, and can directly operate the internal properties and methods of any object

After loading the class, an error is generated in the method area of heap memory Class Object of type

A class has only one object, which contains complete class structure information. We can see the class structure through this object

Under normal conditions:

  1. Introduce the required package class name
  2. Instantiate through new
  3. Get instantiated object

In case of reflection:

  1. Instantiate object
  2. getClass() gets a class object
  3. Get the complete package name

3. Advantages and disadvantages

3.1 advantages

It can dynamically create objects and compile, reflecting great flexibility

3.2 disadvantages

It has an impact on performance. It will be slow to tell the JVM what we want

3.3 functions

Determine the class of any object at run time
 Construct an object of any class at run time
 Judge the member variables and methods of any class at run time
 Generate dynamic proxy

4. Class

stay Object Class. Defines a getClass()Method, which can be inherited by all subclasses
public final Class getClass()
For each class, JRE Keep a constant for them Class Type object

One Class Class objects contain information about a specific structure, such as class properties, methods, constructors, implemented interfaces, etc

Class Objects can only be created by the system. A loaded class JVM There will be an instance in

Each instance of a class remembers which class it was created by Class Generated by instance

Class Objects can only be created by the system

5. Get the instance of Class

5.1 get by class, through class attribute

Class clazz = Person.class;//Safe and reliable, high performance

5.2 use the instance of a class to obtain the information through the getClass() method

Class clazz = person.getClass();

5.3 use the fully qualified pathname of the Class through the static method forName() of the Class

Class clazz = Class.forName("com.xk.pojo.Student");

5.4 built in basic data types

Class name.TYPE
Class clazz = Integer.TYPE;

5.5 get parent type

Class clazz = student.getClass().getSuperClass();

5.6 testing

 //1. Used class attribute, used class
 Class c1 = Student.class;
 //2. Use the method of class and pass the example
 Student student = new Student();
 Class c2 = student.getClass();
 //3. Use the static method of Class
 Class c3 = Class.forName("com.xk.pojo.Student");
 //4. Basic data type
 Class c4 = Integer.class;
 //5. Get parent class
 Class c5 = student.getClass().getSuperclass();

6. java memory analysis


deposit new Objects and arrays
 Can be shared by all threads


Store the basic type variable (including its value) and the variable of the reference object (the specific address of the reference in the heap)

Method area

Include all class and static variable
 Can be shared by all threads

7. Class loading process

7.1 steps

When a program actively uses a class, if the class has not been loaded into memory, the system will initialize the class in three steps

  1. Class loading

    Read the class file of the class, that is, the bytecode file, into memory and create a java.lang.Class object

    This is done by the class loader

  2. Class link

    Merge the binary data of the class into jre

  3. Class initialization

    It is the responsibility of the JVM

7.2 detailed explanation

7.2.1 loading

Load the class file of class into memory, convert the static data into the runtime data structure of the method area, and generate a class object

7.2.2 links

Merge the binary code of the class into the running state of the JVM

Including verification, preparation and analysis

  1. Verification: ensure that the loaded class information complies with the JVM specification and there are no security problems
  2. Preparation: the stage of formally allocating memory for class static variables and setting the default initial value of class variables. These memory are allocated in the method area
  3. Resolution: replace the symbolic reference in the virtual machine constant pool with a direct reference, that is, change the constant name to the address

7.2.3 initialization

The process of executing a class constructor () method

The class constructor () method is generated by the combination of the assignment actions of all variables in the class and the statements of static code blocks automatically at compile time

That is, this method assigns values to all variables and executes static code blocks

A class constructor is the information that constructs the class, not the constructor of the class object

When initializing a class, if its parent class has not been initialized, its parent class needs to be triggered first

8. Memory analysis of class loading process

8.1 examples

public class Test
    public static void main(String[] args) {
        A a=new A();

class A
   static int m=100;
   public A()
       System.out.println("Nonparametric structure");

8.2 memory analysis

8.3 process analysis

8.3.1 class loading

  1. Convert the static data into the runtime data of the method area, as shown in the method area on the far right. There are Test class and class A data in the method area
  2. Generate A Class object representing this Class, as shown in the middle, and generate two Class objects representing Test and A respectively

8.3.2 links

  1. verification

  2. get ready:

    Allocate memory for class variables: see the bottom left of the figure: Main() method, m

    Set default value: m=0

  3. analysis

8.3.3 initialization

The assignment actions and static code blocks of all variables in the class

new A()

8.4 active reference

8.4.1 when does class initialization occur

Active reference of class!!

8.4.2 test:

public class TestA
        System.out.println("Main Method is loaded");

    public static void main(String[] args) throws ClassNotFoundException {
       //1. Active reference
        Son son=new Son();
       //2. Reflection can also cause active reference
class Father
    static int b=2;
        System.out.println("The parent class is loaded");
class Son extends Father
        System.out.println("Subclass loaded");

8.4.3 results:

Main Method is loaded
 The parent class is loaded
 Subclass loaded

8.4.4 conclusion:

1. Class is loaded only once
2. Both actively creating classes and reflection cause class loading

8.5 passive reference

Class initialization does not occur

8.5.1 when accessing a static domain

Only classes that actually declare this domain will be initialized

For example, if a static variable of the parent class is referenced through a subclass, only the parent class will be initialized, and the subclass will not

8.5.2 when defining a class reference through an array

Initialization of this class will not be started

8.5.3 when quoting constants

The constant is stored in the constant pool of the calling class in the link phase

Keywords: Java JavaEE Interview reflection annotations

Added by Ola on Fri, 01 Oct 2021 06:02:20 +0300