This is the 7th day of my participation in the August Text Challenge.More challenges in August

Content preview

  1. Junit unit tests
  2. reflection
  3. annotations

Junit unit Tests:

  • Test categories:
    1. Black box testing: Without writing code, give input values to see if the program can output the desired values.
    2. White-box testing: You need to write code. Focus on the specific execution flow of the program.

  • Junit use: white box test

    • Steps:

      1. Defining a test class (Test case)

        • Advice:
          • Test Class name: Name of the tested class Test CalculatorTest
          • Package name: xxx.xxx.xx.test cn. Shenli. test

      2. Define test methods: can be run independently

        • Advice:
          • Method name: test Method name of the test testAdd()
          • Return value: void
          • Parameter list: empty parameter

      3. So let’s give this method at sign Test

      4. Import junit dependencies

    • Judgment result:

      • Red: Failure
      • Green: Success
      • Typically we use assertion operations to process results
        • AssertEquals (desired result, result of an operation); assert.assertequals

    • Supplement:

      • @Before:
        • Decorated methods are executed automatically before testing methods
      • @After:
        • Decorated methods are executed automatically after the test method is executed

Reflection: The soul of frame design

  • Framework: semi-finished software. Software development can be carried out on the basis of the framework, simplifying the coding

  • Reflection: Encapsulating the components of a class into other objects is the mechanism of reflection

    • Benefits:
      1. These objects can be manipulated while the program is running.
      2. Can be decoupled, improve the scalability of the program.

  • How to get a Class object:

    1. Class.forname (” full Class name “) : Loads the bytecode file into memory and returns a Class object
      • The class name is defined in the configuration file. Read the file and load the class
    2. Class: obtained from the class attribute of the class name
      • Mostly used for passing parameters
    3. Object. GetClass () : The getClass() method is defined in the Object class.
      • A method of obtaining bytecode for an object
    • Conclusion: The same bytecode file (*.class) is loaded only once during a program run, and the class object is the same regardless of which way it is retrieved.

  • Class object features:

    • Access function:

      1. Get the member variables

        • Field[] getFields() : Gets all public decorated member variables

        • Field getField(String name) Gets the public decorated member variable of the specified name

        • Field[] getDeclaredFields() retrieves all member variables, regardless of modifiers

        • Field getDeclaredField(String name)

      2. Get the constructors

        • Constructor<? >[] getConstructors()

        • Constructor getConstructor (class <? >… parameterTypes)

        • Constructor getDeclaredConstructor (class <? >… parameterTypes)

        • Constructor<? >[] getDeclaredConstructors()

      3. Get member methods:

        • Method[] getMethods()

        • Method getMethod(String name, class <? >… parameterTypes)

        • Method[] getDeclaredMethods()

        • Method getDeclaredMethod(String name, class <? >… parameterTypes)

      4. Gets the full class name

        • String getName()

  • Field: member variable

    • Operation:

      1. Set the value

        • void set(Object obj, Object value)

      2. Get the value

        • get(Object obj)

      3. Ignore security checks for access modifier

        • SetAccessible (True): Violent reflex

  • (4) Constructor

    • Create an object:

      • T newInstance(Object… initargs)

      • If you use the null parameter constructor to create an object, the operation can be simplified: newInstance on a Class object

  • Method: Method object

    • Execution method:

      • Object invoke(Object obj, Object… args)

    • Obtain method name:

      • String getName: Gets the method name

  • Case study:

    • Requirement: Write a “framework” that can help us create objects of any class and execute any of its methods without changing any code of the class
      • Implementation:
        1. The configuration file
        2. reflection
      • Steps:
        1. Define the full class name of the object you want to create and the method you want to execute in the configuration file
        2. Load the read configuration file in the program
        3. Use reflection to load class files into memory
        4. Create an object
        5. Execution method

Comments:

  • Concept: Describing a procedure. It’s for the computer

  • Note: Describing a program in words. For programmers

  • Definition: Annotations, also called metadata. A code level specification. It is a feature introduced in JDK1.5 and later and is on the same level as classes, interfaces, and enumerations. It can be declared in front of packages, classes, fields, methods, local variables, method parameters, etc., used to describe and comment these elements.

  • Concept Description:

    • New features after JDK1.5
    • Illustrative of procedure
    • Use annotation: @ annotation name

  • Code analysis: Analyze code by using annotations identified in the code. Compile check: Enable the compiler to implement basic compile checks by using annotations identified in the code.

  • Predefined annotations in the JDK

    • Override: tests whether the method marked by this annotation inherits from the parent class (interface)
    • Deprecated: Indicates the Deprecated content of this annotation
    • @suppresswarnings: SuppressWarnings
      • General pass parameter all@suppressWarnings (“all”)

  • Custom annotations

    • Format: meta annotation public @interface annotation name {attribute list; }

    • Essence: An Annotation is essentially an interface that inherits the Annotation interface by default

      • public interface MyAnno extends java.lang.annotation.Annotation {}

    • Properties: Abstract methods in an interface

      • Requirements:

        1. The return value type of the property has the following values

          • Basic data types
          • String
          • The enumeration
          • annotations
          • An array of the above types

        2. Defines attributes that need to be assigned when used

          1. If the default keyword is used to define the default initialization value of an attribute, the attribute assignment can be omitted when annotations are used.
          2. If only one attribute needs to be assigned and the attribute name is value, the value can be omitted and the value can be defined directly.
          3. When an array is assigned, the value is wrapped in {}. If there is only one value in the array, {} can be omitted

    • Meta-annotation: a annotation used to describe the annotation

      • @target: Describes where the annotation can be used
        • ElementType values:
          • TYPE: applies to classes
          • METHOD: Applies to methods
          • FIELD: Can be applied to member variables
      • @Retention: Describes the phase in which annotations are retained
        • @Retention(retentionPolicy.runtime) : The currently described annotations are retained in the class bytecode file and read by the JVM
      • Documented: Describe whether an annotation is extracted into an API document
      • Inherited: Describes whether an annotation is Inherited by a child class

  • Use (parse) annotations in the program: Get the values of the attributes defined in the annotations

    1. Gets the object (Class, Method,Field) where the annotation is defined

    2. Gets the specified annotation

      • getAnnotation(Class)

      // A subclass of the annotation interface is generated in memory

         public class ProImpl implements Pro{
       public String className(a){
           return "cn.itcast.annotation.Demo1";
       }
       public String methodName(a){
           return "show"; }}Copy the code

    3. Call the abstract method in the annotation to get the configured property values

  • Example: A simple testing framework

  • Summary:

    1. Most of the time, we will use annotations rather than custom annotations
    2. Who are the notes for?
      1. The compiler
      2. For the parser
    3. Annotations are not part of the program, and can be interpreted as a tag