Java.Core.Why do i know class information in compile time ?

You know class information at compile time because Java’s compiler enforces strict static typing. This means that class definitions and type information are determined before your program runs. Here’s why and when you know class information at compile time:

---

1. Statically Defined Classes

When you declare a class explicitly in your code, the Java compiler knows about it during compilation.

Example: Compile-Time Knowledge of Class

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class CompileTimeExample {
    public static void main(String[] args) {
        Class<Animal> animalClass = Animal.class;  // Known at compile time
        System.out.println("Class name: " + animalClass.getName());
    }
}

Why?

• Animal.class is available at compile time because Animal is explicitly declared in the code.
• The compiler verifies that Animal exists and ensures type safety.

---

2. Generics and Type Safety

Java generics work at compile time. If you define a class with generics, you can safely obtain type information using .class.

Example: Generic Class and Type Information

public class GenericExample<T> {
    private Class<T> clazz;

    public GenericExample(Class<T> clazz) {
        this.clazz = clazz;
    }

    public void printClassName() {
        System.out.println("Class: " + clazz.getName());
    }

    public static void main(String[] args) {
        GenericExample<String> example = new GenericExample<>(String.class);
        example.printClassName();
    }
}

Why?

• The compiler ensures that String.class is valid.
• No risk of ClassNotFoundException or runtime errors.

---

3. Directly Referencing Built-in Classes

The Java Standard Library provides built-in classes, which are always known at compile time.

Example: Using Built-in Classes

Class<Integer> intClass = Integer.class;
Class<Double> doubleClass = Double.class;
System.out.println(intClass.getName()); // java.lang.Integer
System.out.println(doubleClass.getName()); // java.lang.Double

Why?

• Integer.class and Double.class are well-defined and part of the JDK.

4. Static Code Analysis & Type Checking

The Java compiler performs static type checking, meaning all class structures and types are verified before the program runs.

Example: Preventing Type Errors

String str = "Hello";
Class<?> clazz = str.getClass();  // Compiler verifies `String.class` exists

However, the following will not compile:

Class<?> clazz = UndefinedClass.class; // Compilation error!

Why?

• UndefinedClass is unknown at compile time.

5. When You Don’t Know Class Information at Compile Time

There are cases where class information is not known at compile time, requiring Class.forName().

Example: Dynamic Class Loading

Class<?> clazz = Class.forName("com.example.SomeClass"); // Only known at runtime

Why?

• The class name is passed as a string.
• The compiler cannot verify its existence at compile time.
• If "com.example.SomeClass" does not exist, a ClassNotFoundException occurs.

---

Summary: Why Class Information is Known at Compile Time

Reason	Why Class Info is Available at Compile Time?
Statically defined classes	Java compiler analyzes class definitions before execution.
Generics & Type Safety	Java enforces strong typing, so class types are known.
Standard Library Classes	Built-in Java classes (e.g., String.class, Integer.class) are always known.
Static Code Analysis	The compiler checks for missing or incorrect class references.

However, if the class name is determined dynamically at runtime, it won’t be known at compile time, and you must use Class.forName().