import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
// Define a custom annotation with runtime retention policy
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyCustomAnnotation {
String value();
}
public class MyClass {
@MyCustomAnnotation("This is a custom annotation")
public void myAnnotatedMethod() {
System.out.println("This method is annotated with MyCustomAnnotation.");
}
public void invokeAnnotation() {
try {
// Accessing the annotation at runtime
MyCustomAnnotation annotation = this.getClass()
.getMethod("myAnnotatedMethod")
.getAnnotation(MyCustomAnnotation.class);
if (annotation != null) {
System.out.println("Annotation value: " + annotation.value());
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.invokeAnnotation();
}
}
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?