Reflection API

public class Main {
    public static void main(String[] args) throws Exception {
        String text = "hello";

        // Three ways to get the same Class object:

        // 1) From an existing object — .getClass()
        Class<?> c1 = text.getClass();        // you HAVE an object

        // 2) From the type itself — .class literal
        Class<?> c2 = String.class;           // you KNOW the type at compile time

        // 3) From a name — Class.forName(...)  (most dynamic)
        Class<?> c3 = Class.forName("java.lang.String"); // type is a String!

        System.out.println("c1 = " + c1.getName());   // java.lang.String
        System.out.println("c2 = " + c2.getName());   // java.lang.String
        System.out.println("c3 = " + c3.getName());   // java.lang.String

        // All three describe the SAME class, so they are identical:
        System.out.println("All equal? " + (c1 == c2 && c2 == c3)); // true

        // Handy questions a Class object can answer:
        System.out.println("Simple name: " + c1.getSimpleName());   // String
        System.out.println("Is interface? " + c1.isInterface());    // false
    }
}

c1 = java.lang.String
c2 = java.lang.String
c3 = java.lang.String
All equal? true
Simple name: String
Is interface? false

import java.lang.reflect.*;

public class Main {
    static class User {
        public String name;
        public int age;
        private String secret = "hidden123";

        public User(String name, int age) { this.name = name; this.age = age; }
        public String greet() { return "Hi, I'm " + name; }
        private String privateMethod() { return "secret: " + secret; }
    }

    public static void main(String[] args) throws Exception {
        User user = new User("Alice", 30);
        Class<?> clazz = user.getClass();        // the User class, at runtime

        // 1) List the fields this class declares
        System.out.println("FIELDS:");
        for (Field f : clazz.getDeclaredFields()) {
            f.setAccessible(true);               // allow reading private fields too
            System.out.println("  " + f.getName()
                    + " = " + f.get(user)        // f.get(user) reads the value
                    + " (" + f.getType().getSimpleName() + ")");
        }

        // 2) Invoke a public method BY NAME (string -> behaviour)
        Method greet = clazz.getMethod("greet"); // look up "greet" with no args
        Object result = greet.invoke(user);      // same as user.greet()
        System.out.println("greet() -> " + result);

        // 3) Reach a PRIVATE method — encapsulation bypassed
        Method priv = clazz.getDeclaredMethod("privateMethod");
        priv.setAccessible(true);                // turn off the access check
        System.out.println("privateMethod() -> " + priv.invoke(user));

        // 4) Create a NEW object with no 'new' keyword
        Constructor<?> ctor = clazz.getDeclaredConstructor(String.class, int.class);
        User bob = (User) ctor.newInstance("Bob", 25); // -> new User("Bob", 25)
        System.out.println("new instance -> " + bob.greet());
    }
}

FIELDS:
  name = Alice (String)
  age = 30 (int)
  secret = hidden123 (String)
greet() -> Hi, I'm Alice
privateMethod() -> secret: hidden123
new instance -> Hi, I'm Bob

import java.lang.annotation.*;
import java.lang.reflect.*;

public class Main {
    // A custom annotation, kept at RUNTIME so reflection can see it.
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Test {}

    static class MathTests {
        @Test public void addsUp()    { if (2 + 2 != 4) throw new AssertionError("math broke"); }
        @Test public void lengthOk()  { if ("hi".length() != 2) throw new AssertionError("len broke"); }
        @Test public void willFail()  { throw new AssertionError("this one is meant to fail"); }
        public void notATest()        { throw new RuntimeException("never runs"); } // no @Test
    }

    public static void main(String[] args) throws Exception {
        Class<?> tests = MathTests.class;
        Object instance = tests.getDeclaredConstructor().newInstance();
        int passed = 0, failed = 0;

        for (Method m : tests.getDeclaredMethods()) {
            // Only run methods annotated with @Test — that's the whole trick.
            if (!m.isAnnotationPresent(Test.class)) continue;
            try {
                m.invoke(instance);
                passed++;
                System.out.println("PASS  " + m.getName());
            } catch (InvocationTargetException e) {
                // The real exception is wrapped — unwrap with getCause()
                failed++;
                System.out.println("FAIL  " + m.getName() + ": " + e.getCause().getMessage());
            }
        }
        System.out.println("Results: " + passed + " passed, " + failed + " failed");
    }
}

PASS  addsUp
PASS  lengthOk
FAIL  willFail: this one is meant to fail
Results: 2 passed, 1 failed