feat: implement custom annotation with runtime retention and reflection access

WHAT was added:
- Defined a custom annotation `@MyAnno1` with attributes:
  • name (required)
  • project (required)
  • date (required)
  • version (optional, default = "13")
- Applied meta-annotations:
  • @retention(RetentionPolicy.RUNTIME) → Annotation info available at runtime.
  • @target(ElementType.TYPE) → Can only be applied to classes/interfaces.
  • @documented → Included in Javadoc.
  • @inherited → Passed down to subclasses if not explicitly overridden.
- Annotated `InBuiltAnnotations` class with `@MyAnno1`.
- Used Java Reflection API (`getAnnotation()`) in `main()` to retrieve and print annotation values.

KEY LEARNINGS:
1. Retention Policies:
   - SOURCE: Annotation discarded by compiler.
   - CLASS: Retained in bytecode but not available at runtime.
   - RUNTIME: Retained in bytecode and accessible via reflection.

2. Annotation Attributes:
   - Work like method declarations inside an annotation.
   - Can have default values (e.g., `version = "13"`).
   - Mandatory attributes must be provided when applying the annotation.

3. Reflection Usage:
   - `Class.getAnnotation(MyAnno1.class)` fetches annotation details at runtime.
   - Null check ensures safe access.

REAL-WORLD APPLICATIONS:
- ✅ Frameworks (Spring, Hibernate) → Use runtime annotations for dependency injection, ORM mappings.
- ✅ API Documentation → With `@Documented`, annotations appear in generated Javadoc.
- ✅ Inheritance-based Config → `@Inherited` lets subclasses automatically reuse parent annotations.
- ✅ Build Tools & Testing → Reflection-driven tools can read annotations dynamically for code generation or validation.

RULE OF THUMB:
- Use `RUNTIME` retention if you need to process annotations during execution (e.g., frameworks, libraries).
- Keep attributes descriptive but concise.
- Leverage default values for optional attributes to reduce boilerplate.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section21AnnotationsandJavaDoc/src/InBuiltAnnotations.java

@@ -1,20 +1,10 @@
-/*
-InBuilt Annonations:
-  1.Retention.
-  2.Documented
-  3.Target
-  4.Inherited
-  5.Repeatable.
-*/
-
-//After One annotaions to another annotaions.
-//Defining Own annontation That affect the another annontaions.
 import java.lang.annotation.*;
 
 @Retention(RetentionPolicy.RUNTIME) // Change from CLASS to RUNTIME
 @Documented
 @Target(ElementType.TYPE)
 @Inherited
+
 @interface MyAnno1 {
     String name();
     String project();
@@ -38,3 +28,54 @@ public static void main(String[] args) {
         }
     }
 }
+
+/*
+InBuilt Annotations:
+  1.Retention.
+  2.Documented
+  3.Target
+  4.Inherited
+  5.Repeatable.
+
+After One annotations to another annotations. Defining Own annotation That affect the another annotations.
+
+1. @interface
+   - Java me custom annotation banane ke liye `@interface` use karte hain.
+   - Annotation ek metadata hai jo class/method/field ke upar extra info provide karta hai.
+
+2. Built-in meta-annotations:
+   - @Retention → batata hai annotation runtime pe available rahega ya sirf compile-time tak.
+     * RetentionPolicy.CLASS (default): compile hone ke baad bhi .class file me hota hai, lekin runtime pe accessible nahi.
+     * RetentionPolicy.RUNTIME: runtime pe reflection ke zariye access kar sakte ho. (yahan use kiya gaya hai)
+   - @Target → annotation kahan lag sakta hai (class, method, field, etc.)
+   - @Inherited → agar ek class pe annotation hai, to uske subclass ko bhi inherit ho jata hai.
+   - @Documented → annotation javadoc me include hoga.
+
+3. Annotation definition (MyAnno1)
+   - Tumne 4 elements define kiye:
+     * name (required)
+     * project (required)
+     * date (required)
+     * version (optional, default = "13")
+
+   Example usage:
+   @MyAnno1(name="Tim", project="Bank", date="2025-02-13")
+
+4. Accessing annotation at runtime
+   - Reflection ke through `.getAnnotation(MyAnno1.class)` se class pe lage annotation ki values fetch ki ja sakti hain.
+   - Example output:
+     Name: Tim
+     Project: Bank
+     Date: 2025-02-13
+     Version: 13
+
+5. Why annotations are useful?
+   - Metadata for frameworks (Spring, Hibernate).
+   - Code generation, validations, dependency injection.
+   - Custom runtime processing (logging, auditing, etc.)
+
+1. Define annotation → `@interface MyAnno1`
+2. Configure meta-annotations → `@Retention(RUNTIME)`, `@Target(TYPE)`
+3. Apply annotation → `@MyAnno1(...)` on class
+4. Use Reflection → `class.getAnnotation(...)` to read values
+*/