annotation member list

Java is a tag that represents the i.e. attached with class, interface, methods or fields to indicate some additional information which can be used by java compiler and JVM.

Annotations in Java are used to provide additional information, so it is an alternative option for XML and Java marker interfaces.

First, we will learn some built-in annotations then we will move on creating and using custom annotations.

There are several built-in annotations in Java. Some annotations are applied to Java code and some to other annotations.

Let's understand the built-in annotations first.

@Override annotation assures that the subclass method is overriding the parent class method. If it is not so, compile time error occurs.

Sometimes, we does the silly mistake such as spelling mistakes etc. So, it is better to mark @Override annotation that provides assurity that method is overridden.

@SuppressWarnings annotation: is used to suppress warnings issued by the compiler.

If you remove the @SuppressWarnings("unchecked") annotation, it will show warning at compile time because we are using non-generic collection.

@Deprecated annoation marks that this method is deprecated so compiler prints warning. It informs user that it may be removed in the future versions. So, it is better not to use such methods.

or Java User-defined annotations are easy to create and use. The element is used to declare an annotation. For example:

Here, MyAnnotation is the custom annotation name.

There are few points that should be remembered by the programmer.

There are three types of annotations.

An annotation that has no method, is called marker annotation. For example:

The @Override and @Deprecated are marker annotations.

An annotation that has one method, is called single-value annotation. For example:

We can provide the default value also. For example:

Let's see the code to apply the single value annotation.

The value can be anything.

An annotation that has more than one method, is called Multi-Value annotation. For example:

We can provide the default value also. For example:

Let's see the code to apply the multi-value annotation.

tag is used to specify at which type, the annotation is used.

The java.lang.annotation. enum declares many constants to specify the type of element where annotation is to be applied such as TYPE, METHOD, FIELD etc. Let's see the constants of ElementType enum:

Example to specify annoation for a class

Example to specify annotation for a class, methods or fields.

@Retention annotation is used to specify to what level annotation will be available.

Example to specify the RetentionPolicy

Example of custom annotation: creating, applying and accessing annotation.

Let's see the simple example of creating, applying and accessing annotation.

File: Test.java

How built-in annotaions are used in real scenario?

In real scenario, java programmer only need to apply annotation. He/She doesn't need to create and access annotation. Creating and Accessing annotation is performed by the implementation provider. On behalf of the annotation, java compiler or JVM performs some additional operations.

By default, annotations are not inherited to subclasses. The @Inherited annotation marks the annotation to be inherited to subclasses.

@Documented

The @Documented Marks the annotation for inclusion in the documentation.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

Table of Contents

Hierarchy of annotations in java, categories of annotations, types of annotations, use of annotations, annotations in java: explained with examples.

Annotations in Java provide additional information to the compiler and JVM . An annotation is a tag representing metadata about classes , interfaces , variables, methods , or fields. Annotations do not impact the execution of the code that they annotate. Some of the characteristics of annotations are:

• Begin with ‘@’
• Do not alter the execution of the program
• Provide supplemental information and help to link metadata with elements of a program such as classes, variables, constructs, methods, etc. 
• Are different from comments since they can affect how the program is treated by the compiler

class Flower {

  public void displayInfo() {

    System.out.println("I am a flower.");

class Rose extends Flower {

  @Override

    System.out.println("I am a rose.");

class Main {

  public static void main(String[] args) {

    Rose r1 = new Rose();

    r1.displayInfo();

I am a rose

In the above example, both the superclass and subclass include the method displayInfo(). However, when the method is called, instead of the method of the superclass, the method of the subclass is called.

Annotations can be categorized broadly into 5 categories:

Category 1: Marker Annotations

The marker annotation is used to mark a declaration. It does not include any members or data. Only the presence of a marker annotation as an annotation is sufficient. An example of Marker Annotation is @Override

@TestAnnotation()

Category 2: Single value Annotations 

A single value annotation consists of a single member only. This annotation allows a shorthand form to specify the value of the member. There is no need to specify the name of the member, only the value of the member has to be specified. There must, however, be a value for the name of the member in order to use this category of annotation. 

@interface AnnotationName{

Int value();

int value() default 0;

To apply single value annotation, use

@AnnotationName(value=6)

Any value can be assigned.

Category 3: Full Annotations 

Full Annotations include multiple data members, values, names, and pairs. 

@TestAnnotation(owner= ”Ravi”, value= ”Class ”)

Category 4: Type Annotations 

As the name suggests, Type Annotations are applied at any place where a type is being used. For instance, the return type of a method can be annotated. Type Annotations are declared with @Target Annotation

// Java Program to Demonstrate Type Annotation

// Importing required classes

import java.lang.annotation.ElementType;

import java.lang.annotation.Target;

// Using target annotation to annotate a type

@Target(ElementType.TYPE_USE)

// Declaring a simple type annotation

@interface TypeAnnoExample{}

// Main class

public class GFG {

    // Main driver method

    public static void main(String[] args) {

        // Annotating the type of a string

        @TypeAnnoExample String string = "This is an example of type annotation";

        System.out.println(string);

        abc();

    // Annotating return type of a function

    static @TypeAnnoExample int abc() {      

        System.out.println("The return type of this function is annotated");      

        return 0;

This is an example of type annotation

The return type of this function is annotated

Become a Software Development Professional

Full stack java developer.

• Kickstart Full Stack Java Developer career with industry-aligned curriculum by experts
• Hands-on practice through 20+ projects, assessments, and tests

Full Stack Web Developer - MEAN Stack

• Comprehensive Blended Learning program
• 8X higher interaction in live online classes conducted by industry experts

Here's what learners are saying regarding our programs:

Mayur Kharad

Product engineer , iks health.

During the lockdown, I realized I needed to upskill myself, and my journey with Simplilearn has been fantastic. I learned many things during the full stack java developer course, thanks to trainer Virendra Sharma. I've always wanted to work in this sector, and after completing my certification in Fullstack Java Development, I got placed at IKS Health through Simplilearn.

Manish Maccha

Software engineer , solventek.

I was looking for a new job with a better salary and position, so I knew I needed to upskill. My experience with Simplilearn was very good. Each topic was innovative and interesting, with quality content. After completing the full stack java developer course, I landed a new job with Neo Geo Info Technologies with a 30% salary hike.

Category 5: Repeating Annotations 

It is possible to apply an annotation to a single item more than once using Repeating Annotations. @Repeatable annotation which is available in java.lang.annotation package is used to annotate the repeating annotations. The container type for the repeatable annotation is specified by the value field of this annotation. The container is specified as an annotation and its value field consists of an array of the repeatable annotation type. In order to use this type of annotation, the container annotation is created first and the annotation type is then specified as an argument to the @Repeatable annotation. 

// Java Program to Demonstrate a Repeatable Annotation

import java.lang.annotation.Annotation;

import java.lang.annotation.Repeatable;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.reflect.Method;

// Make Words annotation repeatable

@Retention(RetentionPolicy.RUNTIME)

@Repeatable(MyRepeatedAnnoDemo.class)

@interface Words

    String word() default "Welcome";

    int value() default 0;

// Create container annotation

@interface MyRepeatedAnnoDemo

    Words[] value();

public class Main { 

    // Repeat Words on newMethod

    @Words(word = "This", value = 1)

    @Words(word = "That", value = 2)

    public static void newMethod()

        Main obj = new Main(); 

        try {

            Class<?> c = obj.getClass(); 

            // Obtain the annotation for newMethod

            Method m = c.getMethod("newMethod"); 

            // Display the repeated annotation

            Annotation anno

                = m.getAnnotation(MyRepeatedAnnoDemo.class);

            System.out.println(anno);

        catch (NoSuchMethodException e) {

            System.out.println(e);

    public static void main(String[] args) { newMethod(); }

@MyRepeatedAnnos(value={@Words(value=1, word="This"), @Words(value=2, word="That")})

Predefined/ Standard Annotations

As indicated in the hierarchy of annotations above, Java provides built-in or standard annotations. @Deprecated, @Override, and @SuppressWarnings are available in java.lang & @Retention, @Documented, @Target, and @Inherited are imported from java.lang.annotation package.

Annotation 1: @Deprecated 

The @Deprecated annotation is used to indicate that the class, field, or method marked is no longer in use and has been replaced by a newer form. Whenever a class, field, or method marked with the @Deprecated annotation is used, the compiler gives a warning message that a deprecated class, field, or method is used. When an element has been deprecated, the Javadoc tag @deprecated tag must be used. There is a difference between the @deprecated tag and @Deprecated annotation. While the @deprecated tag is used for documentation, the @Deprecated annotation is used for runtime reflection.

public class DeprecatedDemo

    @Deprecated

    public void Display()

        System.out.println("Deprecateddemo display()");

    public static void main(String args[])

        DeprecatedDemo d1 = new DeprecatedDemo();

        d1.Display();

Deprecateddemo display()

Annotation 2: @Override

@Override is a marker annotation that can only be used on methods. A method that is annotated with @Override must override a method from the superclass. A compile-time error occurs if the method does not override the method from the superclass. This ensures that the superclass method is overridden and not overloaded. The code becomes more readable and maintenance issues can be avoided. 

// Java Program to Illustrate Override Annotation

class ParentClass

     public void Display()

         System.out.println("Parent Class Display() Method");

     }     

     public static void main(String args[])

         ParentClass t1 = new ChildClass();

         t1.Display();

// Extending above class

class ChildClass extends ParentClass

     @Override

         System.out.println("Child Class Display() Method");

Child Class Display() Method

Annotation 3: @SuppressWarnings 

@SuppressWarnings is used to inform the compiler to suppress the specified compiler warnings. This is done by specifying the warnings to be suppressed by specific names. It can be applied to any type of declaration. There are two categories under which Java groups warnings - deprecated and unchecked. When a legacy code interfaces with a code that uses generics, an unchecked warning is generated.  

// Java Program to illustrate SuppressWarnings Annotation

class DeprecatedDemo

public class SuppressWarningDemo

    // If we comment below annotation, program generates

    // warning

    @SuppressWarnings({"checked", "deprecation"})

Annotation 4: @Documented 

@Documented is a marker interface that specifies to a tool that a particular annotation has to be documented. Annotations are not included in the ‘Javadoc’ comments. By using @Documented annotation in the code, tools like Javadoc can process and include the annotated type in the generated document. 

Annotation 5: @Target 

@Target is used as an annotation to another annotation. The @Target annotation takes only one argument and this argument should be a constant value from the ElementType enumeration. The constants along with the corresponding declaration ars shown in the table below:

One or more values can be specified in a @Target annotation by using a braces-delimited list. For example, to specify an annotation that applies to fields and local variables, the following annotation can be used

@Target({ElementType.FIELD, ElementType.LOCAL_VARIABLE})

Annotation 6: @Inherited 

@Inherited annotation is a marker annotation that is only used on annotation declaration. Only the annotations that are used on class declarations are affected by it. @Inherited causes the subclass to inherit the annotation from a superclass. Hence, when there is a request for a specific annotation to a subclass and it is not present in the subclass, the superclass is checked. If the annotation is present in the superclass and it is annotated with @Inherited, the annotation is returned. 

Annotation 7: User-defined (Custom) 

To annotate program elements, i.e. variables, constructors, methods, etc. user-defined annotations can be used. The user-defined annotations can be applied to the elements Ii.e. variables, constructors, classes, methods) just before their declaration.

Annotations are created by using @interface and are followed by the annotation name. An annotation can also have elements. They appear as methods but the implementation should not be provided for these elements. All the annotations extend java.lang.annotation.Annotation interface. The annotations cannot include the extended clause.

// Java Program to Demonstrate User-defined Annotations

package source;

import java.lang.annotation.Documented;

// User-defined annotation

@Documented

@ interface AnnotationDemo

    String Developer() default "Ravi";

    String Expirydate();

} // will be retained at runtime

// Driver class that uses @AnnotationDemo

public class Demo

    @AnnotationDemo(Developer="Ravi", Expirydate="26-03-2020")

    void fun1()

        System.out.println("Demo method 1");

    @AnnotationDemo(Developer="Kiran", Expirydate="26-03-2021")

    void fun2()

        System.out.println("Demo method 2");

        System.out.println("Welcome");

Annotations are used for the following purposes:

• Instructions to the compiler: There are three types of built-in annotations @Deprecated, @Override, @SuppressWarnings that can be used to give instructions to the compiler, detect errors, and suppress warnings. For example, @Override annotation can be used to instruct the compiler to denote that the annotated method is overriding the method. 
• Compile-time Instructions: Software build tools can generate code, XML files, and more by using the compile-time instructions that the annotations provide. 
• Runtime Instructions: Annotations can also be defined to provide instructions to the program at runtime. These annotations can be accessed using Java Reflection. 

Hope this article was able to give you a thorough understanding about annotations in Java. If you are looking to enhance your software development skills further, we would recommend you check Simplilearn’s Post Graduate Program in Full Stack Web Development . This course, designed in collaboration with Caltech CTME, can help you hone the required skills and make you job-ready in no time. 

If you have any questions or doubts, feel free to post them in the comments below. Our team will review and get back to you with the solutions at the earliest.

Our Software Development Courses Duration And Fees

Software Development Course typically range from a few weeks to several months, with fees varying based on program and institution.

Get Free Certifications with free video courses

Software Development

Getting Started with Full Stack Java Development

Full-Stack Development 101: What is Full-Stack Development ?

Learn from Industry Experts with free Masterclasses

Full Stack Java Development: A 2024 Blueprint for Recession-Proofing Your Career

Java FullStack: Your Gateway to a Recession-Proof Future?

Learn to Develop a Full-Stack E-Commerce Site: Angular, Spring Boot & MySQL

Recommended Reads

Free eBook: Pocket Guide to the Microsoft Certifications

What Is Image Annotation and Why Is It Important in Machine Learning

What is Java: A Beginners Guide To Java

Free eBook: Enterprise Architecture Salary Report

TestNG Annotations in Selenium Webdriver

Java EE Tutorial: All You Need To Know About Java EE

Get Affiliated Certifications with Live Class programs

• PMP, PMI, PMBOK, CAPM, PgMP, PfMP, ACP, PBA, RMP, SP, and OPM3 are registered marks of the Project Management Institute, Inc.

Java in a Nutshell, 5th Edition by David Flanagan

Get full access to Java in a Nutshell, 5th Edition and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

Annotations

Annotations provide a way to associate arbitrary information or metadata with program elements. Syntactically, annotations are used like modifiers and can be applied to the declarations of packages, types, constructors, methods, fields, parameters, and local variables. The information stored in an annotation takes the form of name = value pairs, whose type is specified by the annotation type . The annotation type is a kind of interface that also serves to provide access to the annotation through the Java Reflection API.

Annotations can be used to associate any kind of information you want with a program element. The only fundamental rule is that an annotation cannot affect the way the program runs: the code must run identically even if you add or remove annotations. Another way to say this is that the Java interpreter ignores annotations (although it does make “runtime-visible” annotations available for reflective access through the Java Reflection API). Since the Java VM ignores annotations, an annotation type is not useful unless accompanied by a tool that can do something with the information stored in annotations of that type. In this chapter we’ll cover standard annotation and meta-annotation types like Override and Target . The tool that accompanies these types is the Java compiler, which must process them in certain ways (as we’ll describe later in this section).

It is easy to imagine any number of other uses for annotations. [ 7 ] A local variable might be annotated with a type named NonNull, as an assertion that the variable would never have a null value. An associated (hypothetical) code-analysis tool could then parse the code and attempt to verify the assertion. The JDK includes a tool named apt (for Annotation Processing Tool) that provides a framework for annotation processing tools: it scans source code for annotations and invokes specially written annotation processor classes that you provide. See Chapter 8 for more on apt . Annotations will probably find their widest use in enterprise programming where they may replace tools such as XDoclet , which processes metadata embedded in ad-hoc javadoc comments.

This section begins with an introduction to annotation-related terminology. We then cover the standard annotation types introduced in Java 5.0, annotations supported by javac that you can use in your programs right away. Next, we describe the syntax for writing arbitrary annotations and briefly cover the use of the Java Reflection API for querying annotations at runtime. At this point, we move on to more esoteric material on defining new annotation types, a task that few programmers will ever need to do. This final part of the chapter also discusses meta-annotations.

Annotation Concepts and Terminology

The key concept to understand about annotations is that an annotation simply associates information or metadata with a program element. Annotations never affect the way a Java program runs , but they may affect things like compiler warnings or the behavior of auxiliary tools such as documentation generators, stub generators, and so forth.

The following terms are used frequently when discussing annotations. Of particular importance is the distinction between annotation and annotation type .

An annotation associates arbitrary information or metadata with a Java program element. Annotations use new syntax introduced in Java 5.0 and behave like modifiers such as public or final . Each annotation has a name and zero or more members. Each member has a name and a value, and it is these name = value pairs that carry the annotation’s information.

The name of an annotation as well as the names, types, and default values of its members are defined by the annotation type . An annotation type is essentially a Java interface with some restrictions on its members and some new syntax used in its declaration. When you query an annotation using the Java Reflection API, the returned value is an object that implements the annotation type interface and allows individual annotation members to be queried. Java 5.0 includes three standard annotation types in the java.lang package. We’ll see these annotations in Section 4.3.2 later in this chapter.

The members of an annotation are declared in an annotation type as no-argument methods. The method name and return type define the name and type of the member. A special default syntax allows the declaration of a default value for any annotation member. An annotation appearing on a program element includes name = value pairs that define values for all annotation members that do not have default values and may also include values that override the defaults of other members.

An annotation type that defines no members is called a marker annotation . An annotation of this type carries information simply by its presence or absence.

A meta-annotation is an annotation applied to the declaration of an annotation type. Java 5.0 includes several standard meta-annotation types in the java.lang.annotation package. They are used to specify things like which program elements the annotation can be applied to.

The target of an annotation is the program element that is annotated. Annotations can be applied to packages, types (classes, interfaces, enumerated types, and even annotation types), type members (methods, constructors, fields, and enumerated values), method parameters, and local variables (including loop variables and catch parameters). The declaration of an annotation type may include a meta-annotation that restricts the allowable targets for that type of annotation.

The retention of an annotation specifies how long the information contained in the annotation is retained. Some annotations are discarded by the compiler and appear only in source code. Others are compiled into the class file. Of those that are compiled into the class file, some are ignored by the virtual machine, and others are read by the virtual machine when the class that contains them is loaded. The declaration of an annotation type can use a meta-annotation to specify the retention for annotations of that type. Annotations that are loaded by the VM are runtime-visible and can be queried by the reflective APIs of java.lang.reflect .

When discussing annotations, the term metadata commonly refers to the information carried by an annotation or to the annotation itself. Because this term is used in many different ways in computer programming literature, I have avoided using it in this chapter.

Using Standard Annotations

Java 5.0 defines three standard annotation types in the java.lang package. The following sections describe these annotation types and explain how to use them to annotate your code.

java.lang.Override is a marker annotation type that can be used to annotate methods but no other program element. An annotation of this type serves as an assertion that the annotated method overrides a method of a superclass. If you use this annotation on a method that does not override a superclass method, the compiler issues a compilation error to alert you to this fact.

This annotation is intended to address a common category of programming errors that result when you attempt to override a superclass method but get the method name or signature wrong. In this case, you may have overloaded the method name but not actually overridden the method, and your code never gets invoked.

To use this annotation type, simply include @Override in the modifiers of the desired method. By convention, @Override comes before other modifiers. Also by convention, there is no space between the @ character and the name Override , even though it is technically allowed. Note that because the java.lang package is always automatically imported, you never need to include the package name to use this annotation type. Here is an example in which the @Override annotation is used on a method that fails to correctly override the toString() method of its superclass.

Without the annotation, the typo might go unnoticed and we’d have a puzzling bug: why isn’t the toString( ) method working correctly? But with the annotation, the compiler gives us the answer: the toString() method does not work as expected because it is not actually overridden.

Note that the @Override annotation applies only to methods that are intended to override a superclass method and not to methods that are intended to implement a method defined in an interface. The compiler already produces an error if you fail to correctly implement an interface method.

java.lang.Deprecated is a marker annotation that is similar to the @deprecated javadoc tag. (See Chapter 7 for details on writing Java documentation comments.) If you annotate a type or type member with @Deprecated , it tells the compiler that use of the annotated element is discouraged. If you use (or extend or override) a deprecated type or member from code that is not itself declared @Deprecated , the compiler issues a warning.

Note that the @Deprecated annotation type does not deprecate the @deprecated javadoc tag. The @Deprecated annotation is intended for the Java compiler. The javadoc tag, on the other hand, is intended for the javadoc tool and serves as documentation: it may include a description of why the program element has been deprecated and what it has been superseded by or replaced with.

In Java 5.0, the compiler continues to look for @deprecated javadoc tags and uses them to generate warnings as it always has. This behavior may be phased out, however, and you should begin to use the @Deprecated annotation in addition to the @deprecated javadoc tag.

Here is an example that uses both the annotation and the javadoc tag:

SuppressWarnings

The @SuppressWarnings annotation is used to selectively turn off compiler warnings for classes, methods, or field and variable initializers. [ 8 ] In Java 5.0, Sun’s javac compiler has a powerful -Xlint option that causes it to issue warnings about “lint” in your program—code that is legal but is likely to represent a programming error. These warnings include the “unchecked warning” that appears when you use a generic collection class without specifying a value for its type parameters, for example, or the warning that appears if a case in a switch statement does not end with a break , return , or throw and allows control to “fall through” to the next case.

Typically, when you see one of these lint warnings from the compiler, you should investigate the code that caused it. If it truly represents an error, you then correct it. If it simply represents sloppy programming, you may be able to rewrite your code so that the warning is no longer necessary. For example, if the warning tells you that you have not covered all possible cases in a switch statement on an enumerated type, you can avoid the warning by adding a defensive default case to the switch statement, even if you are sure that it will never be invoked.

On the other hand, sometimes there is nothing you can do to avoid the error. For example, if you use a generic collection class in code that must interact with nongeneric legacy code, you cannot avoid an unchecked warning. This is where @SuppressWarnings comes in: add this annotation to the nearest relevant set of modifiers (typically on method modifiers) to tell the compiler that you’re aware of the issue and that it should stop pestering you about it.

Unlike Override and Deprecated , SuppressWarnings is not a marker annotation. It has a single member named value whose type is String[ ] . The value of this member is the names of the warnings to be suppressed. The SuppressWarnings annotation does not define what warning names are allowed: this is an issue for compiler implementors. For the javac compiler, the warning names accepted by the -Xlint option are also legal for the @SuppressWarnings annotation. It is legal to specify any warning names you want: compilers ignore (but may warn about) warning names they do not recognize.

So, to suppress warnings named unchecked and fallthrough , you could use an annotation that looks like the following. Annotation syntax follows the name of the annotation type with a parenthesized, comma-separated list of name = value pairs. In this case, the SuppressWarnings annotation type defines only a single member, so there is only a single pair within parentheses. Since the member value is an array, curly braces are used to delimit array elements:

We can abbreviate this annotation somewhat. When an annotation has a single member and that member is named “value”, you are allowed (and encouraged) to omit the “value=” in the annotation. So the annotation above should be rewritten as:

Hopefully you will not often have more than one unresolvable lint warning in any particular method and will need to suppress only a single named warning. In this case, another annotation abbreviation is possible. When writing an array value that contains only a single member, you are allowed to omit the curly braces. In this case we might have an annotation like this:

Annotation Syntax

In the descriptions of the standard annotation types, we’ve seen the syntax for writing marker annotations and the syntax for writing single-member annotations, including the shortcut allowed when the single member is named “value” and the shortcut allowed when an array-typed member has only a single array element. This section describes the complete syntax for writing annotations.

An annotation consists of the @ character followed by the name of the annotation type (which may include a package name) followed by a parenthesized, comma-separated list of name = value pairs for each of the members defined by the annotation type. Members may appear in any order and may be omitted if the annotation type defines a default value for that member. Each value must be a literal or compile-time constant, a nested annotation, or an array.

Near the end of this chapter, we define an annotation type named Reviews that has a single member that is an array of @Review annotations. The Review annotation type has three members: “reviewer” is a String , “comment” is an optional String with a default value, and “grade” is a value of the nested enumerated type Review.Grade . Assuming that the Reviews and Review types are properly imported, an annotation using these types might look like this (note the use of nested annotations, enumerated types, and arrays in this annotation):

Another important rule of annotation syntax is that no program element may have more than one instance of the same annotation. It is not legal, for example, to simply place multiple @Review annotations on a class. This is why the @Reviews annotation is defined to allow an array of @Review annotations.

Annotation member types and values

The values of annotation members must be non- null compile-time constant expressions that are assignment-compatible with the declared type of the member. Allowed member types are the primitive types, String , Class , enumerated types, annotation types, and arrays of any of the above types (but not an array of arrays). For example, the expressions 2*Math.PI and " hello"+"world " are legal values for members of type double and String , respectively.

Near the end of the chapter, we define an annotation type named UncheckedExceptions whose sole member is an array of classes that extend RuntimeException . An annotation of this type might look like this:

Annotation targets

Annotations are most commonly placed on type definitions (such as classes) and their members (such as methods and fields). Annotations may also appear on packages, parameters, and local variables. This section provides more information about these less common annotation targets.

A package annotation appears before the package declaration in a file named package-info.java . This file should not contain any type declarations (“package-info” is not a legal Java identifier, so it cannot contain any public type definitions). Instead, it should contain an optional javadoc comment, zero or more annotations, and a package declaration. For example:

When the package-info.java file is compiled, it produces a class file named package-info.class that contains a synthetic interface declaration. This interface has no members, and its name, package-info , is not a legal Java identifier, so it cannot be used in Java source code. It exists simply as a placeholder for package annotations with class or runtime retention.

Note that package annotations appear outside the scope of any package or import declaration. This means that package annotations should always include the package name of the annotation type (unless the package is java.lang ).

Annotations on method parameters, catch clause parameters, and local variables simply appear as part of the modifier list for those program elements. The Java class file format has no provision for storing annotations on local variables or catch clause parameters, so those annotations always have source retention. Method parameter annotations can be retained in the class file, however, and may have class or runtime retention.

Finally, note that the syntax for enumerated type definitions does not allow any modifiers to be specified for enumerated values. It does, however, allow annotations on any of the values.

Annotations and defaults

Annotations must include a value for every member that does not have a default value defined by the annotation type. Annotations may, of course, include values for other members as well.

There is one important detail to understand about how default values are handled. Default values are stored in the class file of the annotation type and are not compiled into annotations themselves. If you modify an annotation type so that the default value of one of its members changes, that change affects all annotations of that type that do not specify an explicit value for that member. Already-compiled annotations are affected, even if they are never recompiled after the change to the type.

Annotations and Reflection

The Reflection API of java.lang.reflect has been extended in Java 5.0 to support reading of runtime-visible annotations. (Remember that an annotation is only visible at runtime if its annotation type is specified to have runtime retention, that is, if the annotation is both stored in the class file and read by the Java VM when the class file is loaded.) This section briefly covers the new reflective capabilities. For full details, look up the interface java.lang.reflect.AnnotatedElement in the reference section. AnnotatedElement represents a program element that can be queried for annotations. It is implemented by java.lang.Package , java.lang.Class , and indirectly implemented by the Method , Constructor , and Field classes of java.lang.reflect . Annotations on method parameters can be queried with the getParameterAnnotations( ) method of the Method or Constructor class.

The following code uses the isAnnotationPresent( ) method of AnnotatedElement to determine whether a method is unstable by checking for an @Unstable annotation. It assumes that the Unstable annotation type, which we’ll define later in the chapter, has runtime retention. Note that this code uses class literals to specify both the class to be checked and the annotation to check for:

isAnnotationPresent() is useful for marker annotations. When working with annotations that have members, though, we typically want to know the value of those members. For this, we use the getAnnotation() method. And here we see the beauty of the Java annotation system: if the specified annotation exists, the object returned by this method implements the annotation type interface, and you can query the value of any member simply by invoking the annotation type method that defines that member. Consider the @Reviews annotation that appeared earlier in the chapter, for example. If the annotation type was declared with runtime retention, you could query it as follows:

Note that these reflective methods correctly resolve default annotation values for you. If an annotation does not include a value for a member with a default value, the default value is looked up within the annotation type itself.

Defining Annotation Types

An annotation type is an interface, but it is not a normal one. An annotation type differs from a normal interface in the following ways:

An annotation type is defined with the keyword @interface rather than with interface . An @interface declaration implicitly extends the interface java.lang.annotation.Annotation and may not have an explicit extends clause of its own.

The methods of an annotation type must be declared with no arguments and may not throw exceptions. These methods define annotation members: the method name becomes the member name, and the method return type becomes the member type.

The return value of annotation methods may be a primitive type, a String , a Class , an enumerated type, another annotation type, or a single-dimensional array of one of those types.

Any method of an annotation type may be followed by the keyword default and a value compatible with the return type of the method. This strange new syntax specifies the default value of the annotation member that corresponds to the method. The syntax for default values is the same as the syntax used to specify member values when writing an annotation. null is never a legal default value.

Annotation types and their methods may not have type parameters—annotation types and members cannot be made generic. The only valid use of generics in annotation types is for methods whose return type is Class . These methods may use a bounded wildcard to specify a constraint on the returned class.

In other ways, annotation types declared with @interface are just like regular interfaces. They may include constant definitions and static member types such as enumerated type definitions. Annotation types may also be implemented or extended just as normal interfaces are. (The classes and interfaces that result from doing this are not themselves annotation types, however: annotation types can be created only with an @interface declaration.)

We now define the annotation types used in our examples. These examples illustrate the syntax of annotation type declarations and demonstrate many of the differences between @interface and interface . We start with the simple marker annotation type Unstable . Because we used this type earlier in the chapter in a reflection example, its definition includes a meta-annotation that gives it runtime retention and makes it accessible to the reflection API. Meta-annotations are covered below.

The next annotation type defines a single member. By naming the member value , we enable a syntactic shortcut for anyone using the annotation:

The next example is more complex. The Reviews annotation type has a single member, but the type of the member is complex: it is an array of Review annotations. The Review annotation type has three members, one of which has an enumerated type defined as a member of the Review type itself, and another of which has a default value. Because the Reviews annotation type is used in a reflection example, we’ve given it runtime retention with a meta-annotation:

Finally, suppose we wanted to annotate methods to list the unchecked exceptions (but not errors) that they might throw. Our annotation type would have a single member of array type. Each element of the array would be the Class of an exception. In order to enforce the requirement that only unchecked exceptions are used, we use a bounded wildcard on Class :

Meta-Annotations

Annotation types can themselves be annotated. Java 5.0 defines four standard meta-annotation types that provide information about the use and meaning of other annotation types. These types and their supporting classes are in the java.lang.annotation package, and you can find complete details in the quick-reference section of the book.

The Target meta-annotation type specifies the “targets” for an annotation type. That is, it specifies which program elements may have annotations of that type. If an annotation type does not have a Target meta-annotation, it can be used with any of the program elements described earlier. Some annotation types, however, make sense only when applied to certain program elements. Override is one example: it is only meaningful when applied to a method. An @Target meta-annotation applied to the declaration of the Override type makes this explicit and allows the compiler to reject an @Override when it appears in an inappropriate context.

The Target meta-annotation type has a single member named value . The type of this member is java.lang.annotation.ElementType[] . ElementType is an enumerated type whose enumerated values represent program elements that can be annotated.

We discussed annotation retention earlier in the chapter. It specifies whether an annotation is discarded by the compiler or retained in the class file, and, if it is retained in the class file, whether it is read by the VM when the class file is loaded. By default, annotations are stored in the class file but not available for runtime reflective access. The three possible retention values (source, class, and runtime) are described by the enumerated type java.lang.annotation.RetentionPolicy .

The Retention meta-annotation type has a single member named value whose type is RetentionPolicy .

Documented is a meta-annotation type used to specify that annotations of some other type should be considered part of the public API of the annotated program element and should therefore be documented by tools like javadoc . Documented is a marker annotation: it has no members.

The @Inherited meta-annotation is a marker annotation that specifies that the annotated type is an inherited one. That is, if an annotation type @Inherited is used to annotate a class, the annotation applies to subclasses of that class as well.

Note that @Inherited annotation types are inherited only by subclasses of an annotated class. Classes do not inherit annotations from interfaces they implement, and methods do not inherit annotations from methods they override.

The Reflection API enforces the inheritance if the @Inherited annotation type is also annotated @Retention(RetentionPolicy.RUNTIME) . If you use java.lang.reflect to query a class for an annotation of an @Inherited type, the reflection code checks the specified class and each of its ancestors until an annotation of the specified type is found or the top of the class hierarchy is reached.

[ 7 ] We won’t have to imagine these uses for long. At the time of this writing, JSR 250 is making its way through the Java Community Process to define a standard set of common annotations for J2SE and J2EE.

[ 8 ] The javac compiler did not yet support the @SuppressWarnings annotation when this chapter was written. Full support is expected in Java 5.1.

Get Java in a Nutshell, 5th Edition now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

Java注解annotation : invalid type of annotation member

Java Validation List Annotations

Last updated: January 8, 2024

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema .

The way it does all of that is by using a design model , a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

>> Take a look at DBSchema

Azure Spring Apps is a fully managed service from Microsoft (built in collaboration with VMware), focused on building and deploying Spring Boot applications on Azure Cloud without worrying about Kubernetes.

The Enterprise plan comes with some interesting features, such as commercial Spring runtime support, a 99.95% SLA and some deep discounts (up to 47%) when you are ready for production.

>> Learn more and deploy your first Spring Boot app to Azure.

And, you can participate in a very quick (1 minute) paid user research from the Java on Azure product team.

Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.

The Jet Profiler was built for MySQL only , so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.

Critically, it has very minimal impact on your server's performance, with most of the profiling work done separately - so it needs no server changes, agents or separate services.

Basically, you install the desktop application, connect to your MySQL server , hit the record button, and you'll have results within minutes:

>> Try out the Profiler

A quick guide to materially improve your tests with Junit 5:

Do JSON right with Jackson

Download the E-book

Get the most out of the Apache HTTP Client

Get Started with Apache Maven:

Working on getting your persistence layer right with Spring?

Explore the eBook

Building a REST API with Spring?

Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:

>> REST With Spring (new)

Get started with Spring and Spring Boot, through the reference Learn Spring course:

>> LEARN SPRING

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI .

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code. And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI :

>> Install Machinet AI in your IntelliJ

Get non-trivial analysis (and trivial, too!) suggested right inside your IDE or Git platform so you can code smart, create more value, and stay confident when you push.

Get CodiumAI for free and become part of a community of over 280,000 developers who are already experiencing improved and quicker coding.

Write code that works the way you meant it to:

>> CodiumAI. Meaningful Code Tests for Busy Devs

Looking for the ideal Linux distro for running modern Spring apps in the cloud?

Meet Alpaquita Linux : lightweight, secure, and powerful enough to handle heavy workloads.

This distro is specifically designed for running Java apps . It builds upon Alpine and features significant enhancements to excel in high-density container environments while meeting enterprise-grade security standards.

Specifically, the container image size is ~30% smaller than standard options, and it consumes up to 30% less RAM:

>> Try Alpaquita Containers now.

Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.

I built the security material as two full courses - Core and OAuth , to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project .

You can explore the course here:

>> Learn Spring Security

Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot .

Get started with Spring Data JPA through the guided reference course:

>> CHECK OUT THE COURSE

Get started with Spring Boot and with core Spring, through the Learn Spring course:

1. Overview

In the following tutorial, we’ll learn the utility of the List variant of the annotations available under the package jakarta.validations.constraints . This annotation helps apply similar types of validations on a field. This also enables us to show different validation messages on the same field .

Let’s understand this in detail with a use case and its implementation.

2. Use Case Details

In this use case, we are going to develop a Java program for validating the fields captured as part of a job application form. The job aspirants can apply for different job levels by entering their personal details like name, years of experience, passport expiry date, etc. The program must validate the fields as shown below:

Usually, @Size , @Pattern , @Max , @Min , @AssertTrue , and @Future annotations of the package jakarta.validation.constraints work pretty well when it comes to displaying generic messages for validation failures. But the List variant of those annotations must be used to meet the last validation requirement, as highlighted above in the table for each of the fields.

Without waiting any more, let’s jump into the implementation.

3. Use Case Implementation

3.1. overview.

For implementing the scenarios discussed in section 2, we create a JobAspirant bean. This bean does 90% of the heavy lifting. All the fields are defined and decorated with the annotations supporting their validations. There is one more important attribute called groups  in the annotations used below. It plays a crucial role in applying validations in specific contexts where they are needed .

Here we are not going to go through the prerequisites on how to use the validation framework . Also, the explanation given in this article should give a great headstart for the readers to explore more on the other annotations of similar nature.

So, in the subsequent sections, let’s go through the steps in applying the validations on each of the fields of the JobAspirant bean.

3.2. Marker Interfaces

The marker interfaces Senior.class , MidSenior.class , and Junior.class have played a significant role in applying the correct validation based on the job level. There is one more important marker interface, AllLevel.class , it’s like a universal signal saying “Hey, this validation must apply regardless of the job level!” . They are assigned to the groups attribute of the annotations to make the validations work appropriately. Let’s take a look at them:

3.3. Validate Name with @Size.List and @Pattern.List

For applying the different validations on the name field, we have used regex extensively with the @Pattern annotations in Pattern.List. Also, by using @Size annotation in Size.List we applied the min and max restriction on name . To understand this, let’s have a look at the annotations applied to the name field:

Here is how we apply validation on the name field:

3.4. Validate Experience with @Min.List and @Max.List

We can apply different min and max years of experience criteria for various job levels using @Min.List and @Max.List.  So, here are the annotations in the JobAspirant bean in action:

Let’s see the @Min annotations in action:

And now, here we check the @Max annotation’s role in the JobAspirant bean:

3.5. Validate Agreement with @AssertTrue.List

Let’s take a look at the field agreement, which is a boolean. Usually, a boolean can be true or false, then what is so special about this validation? What if we want to show separate messages for different job levels? This is how we take care of this using @AssertTrue.List :

Let’s check out validation on the agreement field for a senior-level job in action:

3.6. Validate Passport Expiry Date with @Future.List

Similarly, this kind of validation can be extended to fields of other types as well, such as passportExpiryDate, which is of type Date . To ensure that we show separate messages for expired passports for different job levels, we make use of @Future.List :

Here is the annotation in action:

4. Conclusion

In this tutorial, we learned to use the List variant of the validation annotation along with the groups attribute to effectively apply different validation on the same field in different contexts. Moreover, the examples given here are good enough for the readers to explore more on other List annotations on their own.

As usual, all the examples shown in this article are available over on GitHub .

Just published a new writeup on how to run a standard Java/Boot application as a Docker container, using the Liberica JDK on top of Alpaquita Linux:

>> Spring Boot Application on Liberica Runtime Container.

Slow MySQL query performance is all too common. Of course it is.

The Jet Profiler was built entirely for MySQL , so it's fine-tuned for it and does advanced everything with relaly minimal impact and no server changes.

Explore the secure, reliable, and high-performance Test Execution Cloud built for scale. Right in your IDE:

Basically, write code that works the way you meant it to.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation . Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.

• Python »
• 3.12.4 Documentation »
• Python HOWTOs »
• Annotations Best Practices
• Theme Auto Light Dark |

Annotations Best Practices ¶

Larry Hastings

Accessing The Annotations Dict Of An Object In Python 3.10 And Newer ¶

Python 3.10 adds a new function to the standard library: inspect.get_annotations() . In Python versions 3.10 and newer, calling this function is the best practice for accessing the annotations dict of any object that supports annotations. This function can also “un-stringize” stringized annotations for you.

If for some reason inspect.get_annotations() isn’t viable for your use case, you may access the __annotations__ data member manually. Best practice for this changed in Python 3.10 as well: as of Python 3.10, o.__annotations__ is guaranteed to always work on Python functions, classes, and modules. If you’re certain the object you’re examining is one of these three specific objects, you may simply use o.__annotations__ to get at the object’s annotations dict.

However, other types of callables–for example, callables created by functools.partial() –may not have an __annotations__ attribute defined. When accessing the __annotations__ of a possibly unknown object, best practice in Python versions 3.10 and newer is to call getattr() with three arguments, for example getattr(o, '__annotations__', None) .

Before Python 3.10, accessing __annotations__ on a class that defines no annotations but that has a parent class with annotations would return the parent’s __annotations__ . In Python 3.10 and newer, the child class’s annotations will be an empty dict instead.

Accessing The Annotations Dict Of An Object In Python 3.9 And Older ¶

In Python 3.9 and older, accessing the annotations dict of an object is much more complicated than in newer versions. The problem is a design flaw in these older versions of Python, specifically to do with class annotations.

Best practice for accessing the annotations dict of other objects–functions, other callables, and modules–is the same as best practice for 3.10, assuming you aren’t calling inspect.get_annotations() : you should use three-argument getattr() to access the object’s __annotations__ attribute.

Unfortunately, this isn’t best practice for classes. The problem is that, since __annotations__ is optional on classes, and because classes can inherit attributes from their base classes, accessing the __annotations__ attribute of a class may inadvertently return the annotations dict of a base class. As an example:

This will print the annotations dict from Base , not Derived .

Your code will have to have a separate code path if the object you’re examining is a class ( isinstance(o, type) ). In that case, best practice relies on an implementation detail of Python 3.9 and before: if a class has annotations defined, they are stored in the class’s __dict__ dictionary. Since the class may or may not have annotations defined, best practice is to call the get method on the class dict.

To put it all together, here is some sample code that safely accesses the __annotations__ attribute on an arbitrary object in Python 3.9 and before:

After running this code, ann should be either a dictionary or None . You’re encouraged to double-check the type of ann using isinstance() before further examination.

Note that some exotic or malformed type objects may not have a __dict__ attribute, so for extra safety you may also wish to use getattr() to access __dict__ .

Manually Un-Stringizing Stringized Annotations ¶

In situations where some annotations may be “stringized”, and you wish to evaluate those strings to produce the Python values they represent, it really is best to call inspect.get_annotations() to do this work for you.

If you’re using Python 3.9 or older, or if for some reason you can’t use inspect.get_annotations() , you’ll need to duplicate its logic. You’re encouraged to examine the implementation of inspect.get_annotations() in the current Python version and follow a similar approach.

In a nutshell, if you wish to evaluate a stringized annotation on an arbitrary object o :

If o is a module, use o.__dict__ as the globals when calling eval() .

If o is a class, use sys.modules[o.__module__].__dict__ as the globals , and dict(vars(o)) as the locals , when calling eval() .

If o is a wrapped callable using functools.update_wrapper() , functools.wraps() , or functools.partial() , iteratively unwrap it by accessing either o.__wrapped__ or o.func as appropriate, until you have found the root unwrapped function.

If o is a callable (but not a class), use o.__globals__ as the globals when calling eval() .

However, not all string values used as annotations can be successfully turned into Python values by eval() . String values could theoretically contain any valid string, and in practice there are valid use cases for type hints that require annotating with string values that specifically can’t be evaluated. For example:

PEP 604 union types using | , before support for this was added to Python 3.10.

Definitions that aren’t needed at runtime, only imported when typing.TYPE_CHECKING is true.

If eval() attempts to evaluate such values, it will fail and raise an exception. So, when designing a library API that works with annotations, it’s recommended to only attempt to evaluate string values when explicitly requested to by the caller.

Best Practices For __annotations__ In Any Python Version ¶

You should avoid assigning to the __annotations__ member of objects directly. Let Python manage setting __annotations__ .

If you do assign directly to the __annotations__ member of an object, you should always set it to a dict object.

If you directly access the __annotations__ member of an object, you should ensure that it’s a dictionary before attempting to examine its contents.

You should avoid modifying __annotations__ dicts.

You should avoid deleting the __annotations__ attribute of an object.

__annotations__ Quirks ¶

In all versions of Python 3, function objects lazy-create an annotations dict if no annotations are defined on that object. You can delete the __annotations__ attribute using del fn.__annotations__ , but if you then access fn.__annotations__ the object will create a new empty dict that it will store and return as its annotations. Deleting the annotations on a function before it has lazily created its annotations dict will throw an AttributeError ; using del fn.__annotations__ twice in a row is guaranteed to always throw an AttributeError .

Everything in the above paragraph also applies to class and module objects in Python 3.10 and newer.

In all versions of Python 3, you can set __annotations__ on a function object to None . However, subsequently accessing the annotations on that object using fn.__annotations__ will lazy-create an empty dictionary as per the first paragraph of this section. This is not true of modules and classes, in any Python version; those objects permit setting __annotations__ to any Python value, and will retain whatever value is set.

If Python stringizes your annotations for you (using from __future__ import annotations ), and you specify a string as an annotation, the string will itself be quoted. In effect the annotation is quoted twice. For example:

This prints {'a': "'str'"} . This shouldn’t really be considered a “quirk”; it’s mentioned here simply because it might be surprising.

Table of Contents

• Accessing The Annotations Dict Of An Object In Python 3.10 And Newer
• Accessing The Annotations Dict Of An Object In Python 3.9 And Older
• Manually Un-Stringizing Stringized Annotations
• Best Practices For __annotations__ In Any Python Version
• __annotations__ Quirks

Previous topic

Python support for the Linux perf profiler

Isolating Extension Modules

• Report a Bug
• Show Source

This is the complete list of members for CNode_annotation , including all inherited members.

• google_books_api
• AnnotationLayerSummary

This is the complete list of members for google_books_api::Annotation::AnnotationLayerSummary , including all inherited members.

© 2020 Google - Privacy Policy - Terms and Conditions - About Google

• EmbedAnnotationData

This is the complete list of members for clang::EmbedAnnotationData , including all inherited members.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How to annotate a list that may or MAY NOT have different types?

python version: 3.10.2

It was of my understanding that list[str|int] should allow three distinct types of values:

• List of only strings ( list[str] )
• List of only ints ( list[int] )
• List of both strings and ints ( list[str|int] )

Is this assumption right, or am I understanding it wrong ? because that's not what happens when I'm coding:

It accepts lists with only strings or only ints, but only if I don't specify that the list in question only accepts one of these values. x and y are explicitly declared as lists that only accepts one of this values ( int or str ), and because of that they are rejected. Is this really what is supposed to happen, or is it a bug ?

• type-hinting
• python-typing

• 2 Please do not upload images of code/errors when asking a question. Include it as a formatted code block instead of an image. –  pho Commented May 11, 2022 at 16:32
• 1 which version of python are you using? –  deadshot Commented May 11, 2022 at 16:35

Here's the problem:

The type checker doesn't know or care what test does with the list. It only cares about what it might do to the list. One thing that would be legal is to add a str to the list: you said that (the parameter) x has type list[str|int] . That's fine if the list passed to test has type list[str|int] or list[str] ; it's not fine if the list has type list[int] .

That is, test does not accept lists that have either str or int values: it accepts lists that must be able to contain str or int values.

The problem goes away when you change the type of the parameter to Sequence[str|int] , because a Sequence does not permit mutation. The type guarantees that if you provide a list[int] value, test won't try to add a str to the list.

• Just a minor correction: both list[str] and list[int] are "not fine" . On the first image, both x and y show errors. –  João Vitor Barbosa Commented May 12, 2022 at 3:19
• So, if I don't plan to add values, I can use Sequence . And if I really need it to be a list , the only way to get what I want is: x: list[str] | list[int] | list[str | int] ? –  João Vitor Barbosa Commented May 12, 2022 at 3:21
• You can, but you still aren't going to be able to add, say, an int to x inside the function if there is a possibility it's a (statically typed) list[str] . –  chepner Commented May 12, 2022 at 12:29
• 1 list[str|int] is probably fine as the annotation , but if you want to pass a value that was statically typed as list[int] or list[str] , you'll have to cast it, and then it's your responsibility to make sure that the function doesn't do anything to break your static guarantee that the list is homogenous. –  chepner Commented May 12, 2022 at 12:38
• Yeah, it makes sense I guess. Because if I add a int , inside the function, in a list declared as list[str] outside the function, it will be changed as well. It's kinda dull, but makes sense at least... Thanks for the answer! –  João Vitor Barbosa Commented May 12, 2022 at 13:56

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python list type-hinting python-typing pylance or ask your own question .

• Featured on Meta
• Upcoming sign-up experiments related to tags
• The return of Staging Ground to Stack Overflow
• Should we burninate the [lib] tag?
• Policy: Generative AI (e.g., ChatGPT) is banned
• What makes a homepage useful for logged-in users

Hot Network Questions

• Cancellation of the Deutschlandticket
• Can I replace a GFCI outlet in a bathroom with an outlet having USB ports?
• Film/series involving a rich/poor divide and a guy and a girl who fall for one another
• Brakes not going back on their own
• What exactly is beef bone extract, beef extract, beef fat (all powdered form) and where can I find it?
• Is the OP_PUSHBYTES_X opcode always required after OP_RETURN?
• A chess engine in Java: generating white pawn moves
• Have children's car seats not been proven to be more effective than seat belts alone for kids older than 24 months?
• Isn't it problematic to look at the data to decide to use a parametric vs. non-parametric test?
• Collaborators write their departments for my (undergraduate) affiliation
• Does "my grades suffered" mean "my grades became worse" or "my grades were bad"?
• How to join two PCBs with a very small separation?
• Could space habitats have large transparent roofs?
• How do I pour *just* the right amount of plaster into these molds?
• Reconstructing Euro results
• How are pursed and rounded synonymous?
• Separate unidirectional streams vs single bidirectional stream
• Why is polling data for Northern Ireland so differently displayed on national polling sites?
• Can God transcend human logic and reasoning?
• Trying to determine what this item is
• Is it consistent with ZFC that the real line is approachable by sets with no accumulation points?
• How will the ISS be decommissioned?
• Homebrew spell to improve familiar link before combat
• In By His Bootstraps (Heinlein) why is Hitler's name Schickelgruber?

This is the complete list of members for Aspose::Pdf::Annotations::RegistrationMarkAnnotation , including all inherited members.