Model Answer: "final is a modifier meaning "cannot be changed" — applies to variables (reassignment prevented), methods (cannot be overridden), and classes (cannot be extended). finally is a block in try-catch-finally that always executes after try/catch, used for cleanup like closing resources. finalize() is a deprecated Object method called by garbage collector before reclaiming memory — it is not a substitute for proper resource cleanup and should not be relied upon.

Model Answer: "Yes, if the variable is marked final and assigned exactly once, you can initialize it conditionally across multiple branches — as long as the compiler can prove all execution paths assign it exactly once. For instance variables, initialization must occur in every constructor. For local variables, all code paths must assign before use.

Model Answer: "There is no runtime performance impact from marking variables final. However, the JIT compiler can make optimizations for final variables: inlining constant values, eliminating redundant reads, and removing synchronization on final fields of effectively immutable objects. The primary benefit of final is compile-time safety, not runtime performance.

Model Answer: "var enables local variable type inference — the compiler deduces the type from the right-hand side. Use it when the type is obvious and improves readability: var list = new ArrayList(); vs ArrayList list = new ArrayList();. Restrictions: var cannot be used for instance variables, method parameters, or return types. It also cannot be used with lambda expressions or method references where the target type is not yet established.

Model Answer: "static final primitives or Strings are single values — compile-time constants that inline wherever used. enum is a type representing a fixed set of named values, each with its own identity. Enums provide type safety (no invalid values), better debugging (named constants), and can hold state and behavior. Use enums when you have a discrete set of related constants; use static final for simple, unrelated constants like MAX_BUFFER_SIZE.

Model Answer: "Instance variables (fields) are declared at the class level and have default values (reference types default to null, primitives have type-specific defaults). They live as long as the object lives. Local variables (method variables) are declared inside methods and must be explicitly initialized before use — the compiler will not allow reading an uninitialized local variable. Local variables go out of scope when the method completes. Instance variables are subject to shadowing rules; local variables cannot be shadowed in their own scope but can be shadowed by parameters or inner blocks with the same name.

Model Answer: "var enables local variable type inference — the compiler deduces the type from the right-hand side. Use it when the type is obvious and improves readability: var list = new ArrayList(); vs ArrayList list = new ArrayList();. Restrictions: var cannot be used for instance variables, method parameters, or return types. It also cannot be used with lambda expressions or method references where the target type is not yet established.

Model Answer: "A blank final variable is a final variable that is not initialized at declaration but is assigned exactly once before use. For instance variables, the blank final must be assigned in every constructor (or in an initializer block if there's only one constructor). For local variables, all code paths must assign before use or the compiler errors. Blank finals allow you to have final guarantees (assigned exactly once) while deferring the value assignment. A common pattern: final int result; if (condition) { result = computeValue(); } else { result = -1; } — the compiler verifies all paths assign exactly once.

Model Answer: "A variable is effectively final if it is not explicitly marked final but could be — meaning it is never reassigned after initialization. The compiler treats effectively final variables the same as final for the purpose of lambda expressions and anonymous classes — they can be used in closures. A variable is explicitly final if declared with the final keyword. Effective finality is a concept introduced in Java 8 to simplify coding — you don't need to add final everywhere if you never reassign. Note: modifying the contents of a reference (e.g., list.add()) does not make a variable non-effectively-final — only reassignment of the variable itself matters.

Model Answer: "Variable shadowing occurs when a variable in an inner scope has the same name as a variable in an outer scope. In Java, this is allowed for local variables and parameters, but not for instance variables — declaring a field with the same name as an inherited field causes a compile error. Shadowing makes code confusing — count inside the block refers to the inner variable, not the outer one. To avoid: use distinct names, minimize scope widths, and be explicit about which variable you're referencing (this.count for instance fields vs local parameters). Modern IDEs warn about shadowing. The compiler will error on field shadowing in subclasses.

Model Answer: "No — var is only valid for local variable declarations (inside methods, constructors, or initializer blocks). You cannot use var for instance variables, static variables, method parameters, or return types. This restriction exists because var relies on type inference from an initializer expression, and these other contexts either lack initializers at the declaration site or would create ambiguous situations for the compiler. Use explicit types for all class-level and method-signature declarations.

Model Answer: "For reference types including String, uninitialized instance variables default to null. This is different from primitives which get type-specific defaults (0, false, etc.). A field declared as private String name; has value null until explicitly assigned. Note: null is not the same as empty string ("") — null means "no object reference", while empty string is an actual String object with zero characters. Be aware that calling methods on a null reference throws NullPointerException — always handle null possibility for reference type fields.

Model Answer: "Local variables are declared inside the method body and must be initialized before use; they have method scope. Method parameters (arguments) are declared in the method signature and receive values from the caller at invocation; they are initialized by the caller. Both are stored on the stack, but parameters are initialized on method entry, while locals must be explicitly assigned. Parameters cannot be reassigned in a way that affects the caller (Java is pass-by-value), while local variables can be reassigned freely. Both local variables and parameters are not visible outside the method.

Model Answer: "Yes — final on a reference type only means the reference cannot be reassigned. The object's contents can still be modified. Example: final List list = new ArrayList<>(); list.add("item"); // perfectly legal. The list reference is locked, but add/modify/remove operations on the list itself are allowed. To make the contents immutable, use immutable collections: final List list = List.of("item"); — this creates an unmodifiable list. Or use Collections.unmodifiableList() for a defensive copy. This distinction between reference immutability and object immutability is critical for correct use of final.

Model Answer: "A variable declared inside an if block (or any block { }) has block scope — it is only visible and usable within that block. After the block ends (the closing brace), the variable is out of scope and (if primitive) eligible for GC. This is narrower than method scope. Variables in nested blocks can shadow outer variables with the same name. Example: if (condition) { int count = 5; ... } // count not accessible here. To use a block-scoped variable outside the block, assign it to a variable declared before the block (which may have its own initialization requirements — the variable must be definitely assigned before use).

Model Answer: "static final on a reference type means the reference is constant — it can never be reassigned to point to a different object. However, the object itself is not protected from modification unless it's immutable. Example: static final List CONFIG = new ArrayList<>(); — CONFIG always points to the same ArrayList, but you can still call CONFIG.add("x"). To create a truly immutable collection, use: static final List CONFIG = List.of("x", "y"); (Java 9+) or static final List CONFIG = Collections.unmodifiableList(List.of("x", "y"));. The choice matters for thread safety and defensive programming.

Model Answer: "A compile-time constant (static final with a compile-time expression) is inlined at every usage site by the compiler — the value is substituted directly into the bytecode. It must be a primitive or String initialized with a compile-time constant expression. A runtime constant (static final with non-compile-time initialization) is evaluated once at class loading time and stored as a field. Both are immutable once set, but compile-time constants can enable more aggressive optimizations. Runtime constants are useful when the value is not known until runtime (e.g., static final Date START_DATE = new Date();).

Model Answer: "Yes — you can declare method parameters as final: void process(final int count, final String name). This prevents reassignment to the parameter inside the method body. This is useful as documentation and for preventing accidental modification, especially in long methods or when the parameter is used in inner classes/lambdas. For inner classes and lambdas, effectively final or explicitly final variables from the enclosing scope can be captured. Note: marking a parameter final does not affect the caller — the caller passes a value, and inside the method the parameter acts like a local variable that cannot be reassigned.

Model Answer: "Definite assignment is a Java rule ensuring that local variables are definitely assigned before use. The compiler performs flow analysis to verify that every path to a variable use assigns the variable. If a variable might be used without being assigned on some path, the compiler errors: "variable might not have been initialized". This rule applies to local variables and parameters (for blank final), but not to instance/static fields which have default values. Understanding definite assignment helps you write code where initialization is clear and the compiler can catch potential bugs before runtime.

Model Answer: "final is a modifier meaning "cannot be changed" — applies to variables (reassignment prevented), methods (cannot be overridden), and classes (cannot be extended). finally is a block in try-catch-finally that always executes after try/catch, used for cleanup like closing resources. finalize() is a deprecated Object method called by garbage collector before reclaiming memory — it is not a substitute for proper resource cleanup and should not be relied upon. Effective Java recommends avoiding all three: use final for immutable references, try-with-resources for cleanup, and proper close() methods instead of finalize().