ਰਿਫਲੈਕਸ਼ਨ ਅਤੇ ਐਨੋਟੇਸ਼ਨ ਕਿਸ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ?

Question

Accepted Answer

**Reflection** ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ **ਕਲਾਸਿਜ਼, methods, ਅਤੇ fields ਨੂੰ runtime ਤੇ inspect ਅਤੇ manipulate** ਕਰਨ ਦੇਤਾ ਹੈ — ਉਹ ਵੀ ਜੋ compile time ਤੇ ਅਣਜਾਣ ਹੋਣ। **Annotations** code ਵਿੱਚ metadata ਨੂੰ attach ਕਰਦੇ ਹਨ ਜੋ tools ਅਤੇ frameworks ਪੜ੍ਹਦੇ ਹਨ (ਅਕਸਰ reflection ਦੁਆਰਾ) ਵਿਹਾਰ ਨੂੰ drive ਕਰਨ ਲਈ। ਇਕਠੇ ਉਹ Java's framework "magic" ਦਾ ਬਹੁਤ ਕੁਝ ਸ਼ਕਤੀ ਦਿੰਦੇ ਹਨ (Spring, JPA, JUnit)।

## Reflection — runtime inspection ਅਤੇ invocation

```java
// examine a class's structure at runtime, without knowing it at compile time
Class<?> clazz = Class.forName("com.example.User");

for (Field field : clazz.getDeclaredFields()) {
    System.out.println(field.getName() + ": " + field.getType());
}
for (Method method : clazz.getDeclaredMethods()) {
    System.out.println(method.getName());
}

// create instances and invoke methods dynamically
Object instance = clazz.getDeclaredConstructor().newInstance();
Method m = clazz.getMethod("setName", String.class);
m.invoke(instance, "Ann");        // call setName("Ann") reflectively

// even access private members (frameworks use this for DI)
Field f = clazz.getDeclaredField("secret");
f.setAccessible(true);             // bypass private access
```

Reflection ਕੋਡ ਨੂੰ dynamically types ਨੂੰ discover ਅਤੇ use ਕਰਨ ਦੇਤਾ ਹੈ — classes ਨੂੰ name ਦੁਆਰਾ instantiate ਕਰੋ, fields ਨੂੰ read/set ਕਰੋ, methods ਨੂੰ invoke ਕਰੋ — ਜੋ ਹੈ ਕਿ ਕਿਵੇਂ frameworks *ਤੁਹਾਡੀ* classes ਤੇ ਕਾਮ ਕਰਦੇ ਹਨ ਬਿਨਾ ਉਹਨਾਂ ਨੂੰ advance ਵਿੱਚ ਜਾਣੇ।

## Annotations — tools/frameworks ਲਈ metadata

```java
// built-in and framework annotations attach metadata
@Override               // compiler check
@Deprecated             // marks outdated API
@Entity                 // JPA: this class maps to a DB table
@Autowired              // Spring: inject a dependency here
@Test                   // JUnit: this method is a test
```

## ਇੱਕ custom annotation ਨੂੰ define ਕਰਨਾ

```java
@Retention(RetentionPolicy.RUNTIME)   // available at runtime (readable via reflection)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
}

// using it
class Service {
    @Loggable("audit")
    void process() { ... }
}
```

## ਕਿਵੇਂ ਉਹ combine ਕਰਦੇ ਹਨ: frameworks annotations ਨੂੰ reflection ਦੁਆਰਾ ਪੜ੍ਹਦੇ ਹਨ

```java
// a framework scans methods, finds the annotation, and acts on it
for (Method m : clazz.getDeclaredMethods()) {
    if (m.isAnnotationPresent(Loggable.class)) {
        Loggable l = m.getAnnotation(Loggable.class);
        // wrap/log/intercept the method based on the metadata
    }
}
```

ਇਹ Spring (`@Autowired`, `@Component`), JPA (`@Entity`), JUnit (`@Test`), validation (`@NotNull`) — ਦਾ core mechanism ਹੈ — ਉਹ ਤੁਹਾਡੇ annotated code ਨੂੰ reflection ਦੁਆਰਾ scan ਕਰਦੇ ਹਨ ਅਤੇ behavior ਨੂੰ wire ਕਰਦੇ ਹਨ।

## Trade-offs

```text
✗ Reflection is SLOWER than direct calls (runtime lookup), bypasses compile-time
  type checking, and can break encapsulation (setAccessible) → use judiciously
✓ But it's essential for generic frameworks, DI, serialization, testing tools
```

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Reflection ਅਤੇ annotations **Java's framework ecosystem ਦੇ machinery** ਹਨ।

Reflection generic, dynamic behavior ਨੂੰ enable ਕਰਦਾ ਹੈ — classes ਨੂੰ runtime ਤੇ inspect ਅਤੇ operate ਕਰਨਾ compile-time knowledge ਬਿਨਾ — ਜੋ ਹੈ ਕਿ dependency injection, ORMs (objects ਨੂੰ tables ਵਿੱਚ mapping ਕਰਨਾ), serialization libraries (Jackson fields ਪੜ੍ਹਨਾ), ਅਤੇ testing frameworks ਤੁਹਾਡੀ arbitrary classes ਤੇ ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ।

Annotations declarative metadata ਫਰਾਹਮ ਕਰਦੇ ਹਨ ਜੋ ਇਹ tools (reflection ਦੁਆਰਾ) ਪੜ੍ਹਦੇ ਹਨ ਤਾਂ ਜੋ ਉਹਨਾਂ ਦਾ behavior drive ਕਰਨ ਲਈ, verbose configuration ਨੂੰ simple markers ਨਾਲ ਬਦਲਦੇ ਹਨ (`@Entity`, `@Autowired`, `@Test`)।

je ਸਮਝਣਾ Spring, JPA, ਅਤੇ JUnit ਦਾ "magic" ਕਿਵੇਂ achieve ਕਰਦੇ ਹਨ ਜ਼ਾਹਰ ਕਰਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਆਪਣੇ ਆਪ ਤਰਾਂ ਦੇ framework-like tools ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ, ਅਤੇ performance/safety trade-offs (slower, type checking bypass) ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ appropriately ਵਰਤੋ।

ਇਹ advanced ਪਰ Java ecosystem ਵਿੱਚ deeply ਕਾਮ ਕਰਨ ਲਈ essential knowledge ਹੈ।