Annotations & Reflection — Metadata That Powers Modern Java

8. Practice Problems

Try each problem yourself before opening the answer.

1. Create a custom annotation @Version that takes an integer value and attach it to a class.
   একটি custom annotation @Version তৈরি করুন যা integer value নেবে, এবং একটি class-এ প্রয়োগ করুন। Reflection দিয়ে সেটি প্রিন্ট করুন।
   ✨ Show Answer (উত্তর দেখুন)

   Main.java

   import java.lang.annotation.*;
   
   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.TYPE)
   @interface Version { int value(); }
   
   @Version(3)
   class App {}
   
   class Main {
       public static void main(String[] args) {
           Version v = App.class.getAnnotation(Version.class);
           System.out.println("App version = " + v.value());
       }
   }

   Run Copy

2. Explain the difference between RetentionPolicy.CLASS and RetentionPolicy.RUNTIME.
   RetentionPolicy.CLASS এবং RetentionPolicy.RUNTIME-এর পার্থক্য ব্যাখ্যা করুন।
   ✨ Show Answer

   Answer: Both retain the annotation in the compiled .class file, but only RUNTIME makes it visible to the reflection API after the class is loaded. CLASS is for tools that scan bytecode offline (e.g. some static analyzers). If a framework such as Spring needs to discover your annotation while the JVM is running, you MUST use RUNTIME.

   দুটিই .class ফাইলে annotation রাখে, তবে শুধু RUNTIME class load হওয়ার পর reflection API-তে দৃশ্যমান। CLASS bytecode scanner-দের জন্য। Spring-এর মতো framework যদি runtime-এ annotation খুঁজে পেতে চায়, RUNTIME-ই দিতে হবে।

3. Use reflection to list every method of java.util.ArrayList that starts with "add".
   Reflection ব্যবহার করে java.util.ArrayList-এর সেই method-গুলো list করুন যেগুলো "add" দিয়ে শুরু হয়।
   ✨ Show Answer

   Main.java

   import java.util.ArrayList;
   import java.lang.reflect.Method;
   
   class Main {
       public static void main(String[] args) {
           for (Method m : ArrayList.class.getDeclaredMethods()) {
               if (m.getName().startsWith("add")) {
                   System.out.println(m.getName() + " / params=" + m.getParameterCount());
               }
           }
       }
   }

   Run Copy

4. Why is Method.invoke() slower than a direct call? Give one way to mitigate it.
   Method.invoke() কেন সাধারণ method call-এর চেয়ে ধীর? এটি কমানোর একটি উপায় বলুন।
   ✨ Show Answer

   Answer: Reflective invocation goes through access checks, autoboxing of primitive arguments into Object[], and dynamic dispatch — none of which the JIT can optimize as well as a direct virtual call. Mitigations: (1) cache the Method object once, do not look it up per call, (2) call setAccessible(true) once to skip access checks, (3) for hot paths, use MethodHandle via java.lang.invoke — its JIT-visible and nearly as fast as a direct call.

5. Build a tiny DI container: given a class that has a @Inject-annotated field, create an instance and set the field to a hard-coded "PaymentAPI" string.
   একটি ছোট DI container বানান: class-এ @Inject-annotated field থাকলে সেটিতে একটি hard-coded "PaymentAPI" string inject করুন।
   ✨ Show Answer

   Main.java

   import java.lang.annotation.*;
   import java.lang.reflect.Field;
   
   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.FIELD)
   @interface Inject {}
   
   class OrderService {
       @Inject String paymentApi;
       public String toString() { return "OrderService using " + paymentApi; }
   }
   
   class Main {
       public static void main(String[] args) throws Exception {
           OrderService o = OrderService.class.getDeclaredConstructor().newInstance();
           for (Field f : OrderService.class.getDeclaredFields()) {
               if (f.isAnnotationPresent(Inject.class)) {
                   f.setAccessible(true);
                   f.set(o, "PaymentAPI");
               }
           }
           System.out.println(o);
       }
   }

   Run Copy

   এটিই Spring-এর @Autowired-এর সরলতম সংস্করণ।