Common built-in annotations in Java are mainly divided into three categories: annotations used by the compiler, annotations used to help the tool process, and annotations available at runtime. 1. @Override is used to rewrite the parent class method. If the parent class method is not really overwritten, the compiler will report an error. It is suitable for scenarios where the method is rewrite in inheritance; 2. @Deprecated marks the element is outdated, prompting developers to avoid using it and may be removed in the future. It is usually used with the @deprecated of Javadoc; 3. @SuppressWarnings suppresses compiler warnings, suitable for situations where specific "safety" warnings are ignored, but should be used with caution to prevent potential problems; 4. Meta annotations include @Retention, @Target, @Documented and @Inherited, which are used to define the life cycle of other annotations, their function goals, whether documents are generated and whether they can be inherited; 5. Java 8 has added @FunctionalInterface and @Repeatable, respectively, are used to ensure that there is only one abstract method for functional interfaces and allow reuse of annotations, which enhances code expression and security.

Common built-in annotations in Java are mainly divided into three categories: annotations used by the compiler, annotations used to help the tool process, and annotations available at runtime. These annotations can help developers write clearer, safer, and maintainable code.

1. @Override —— means rewriting the parent class method

This annotation is used on the subclass method, indicating that the method overrides the parent class method. If @Override is added but does not really overwrite the parent class method (such as misspelling of method names or mismatched parameters), the compiler will report an error.
Use scenarios are very common. For example, when you inherit a class and rewrite its toString() or equals() method, it is recommended to add this annotation to avoid not knowing whether the rewrite is successful due to spelling errors.

Tips: Some IDEs will automatically complete when you enter @Overr... to help you check whether the parent class method is really overwritten.

2. @Deprecated — mark an element that is outdated

When you see a class, method, or field marked @Deprecated , it means it is still usable, but it is not recommended by the official and may be removed in a future version. It is usually used with the @deprecated tag of Javadoc to illustrate alternatives.

For example:

 @Deprecated(since = "1.8", forRemoval = true)
public void oldMethod() {
    // Obsolete method body}

If you call a method marked @Deprecated , the compiler may give you a warning to consider using a new method instead.

3. @SuppressWarnings - Suppress compiler warnings

Sometimes you will encounter some "safe" warnings, such as using raw type or unchecked conversions. At this time, you can use @SuppressWarnings("unchecked") or @SuppressWarnings("rawtypes") to tell the compiler: "I know what I'm doing, please don't call a warning."

Notes on using:

• The scope is as small as possible, and it is best to add it to specific methods or variables, rather than the entire class.
• Avoid abuse, which may mask the real potential problems.

4. Meta-annotations - Annotations

In addition to the above common annotations in daily development, some are used to define other annotations, called meta annotations. Common ones include:

• @Retention : defines the life cycle of annotations (SOURCE, CLASS, RUNTIME)
• @Target : Define where annotations can be used (classes, methods, fields, etc.)
• @Documented : Let the annotation appear in the generated Javadoc
• @Inherited : Allow subclasses to inherit annotations on parent class

For example, if you want to define a custom annotation that is valid at runtime, you can write it like this:

 @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
}

5. Several practical notes added to Java 8

Starting from Java 8, some new annotations for enhanced features have been added, such as:

• @FunctionalInterface : Used to annotate functional interfaces to ensure that it has only one abstract method. If you accidentally add a second abstract method, the compiler will report an error.
• @Repeatable : Allows the same annotation to be reused multiple times on an element (previously only written once)

These two are particularly useful when writing frameworks or libraries, and can improve the expressiveness and security of the code.

Basically that's it. Although it doesn't seem to be much, using these annotations in actual development can effectively improve the quality of the code and allow the compiler to help you do more checking.

The above is the detailed content of What are common built-in annotations?. For more information, please follow other related articles on the PHP Chinese website!