Variables

final means the variable can be assigned a value only once. After that first assignment you cannot change it. Trying to reassign it is a compile error, so the program will not even build.

Shadowing happens when a variable in an inner scope has the same name as one in an outer scope, so the inner one hides the outer one. A classic case is a constructor parameter named the same as a field.

Local variables live inside a method and disappear when it ends. Instance variables belong to each object and live as long as the object. Static variables belong to the class itself, so there is just one copy shared by everything.

var lets you declare a local variable without writing its type; the compiler figures out the type from the value you assign. The variable still has a fixed type — var just saves you from typing it.

final stops you from pointing the variable at a different object. It does not stop the object itself from changing. So a final List can still have items added to it; you just cannot replace the whole list with a new one.

A Java constant is usually a static final field, e.g. public static final int MAX = 100;. static means one shared copy for the whole class instead of one per object, and final means it cannot be reassigned. The naming convention is ALL_CAPS_WITH_UNDERSCORES.

Java looks at the closest (innermost) scope first. If a local variable or parameter has the name, that wins; the field is only used if no closer variable has the name. Use this.name to force the field.

You can only use var for local variables that have a value assigned right away. You cannot use it for class fields, method parameters, method return types, or a local variable declared with no initializer.

A static method belongs to the class, not to any object, so it has no specific object whose instance variables it could read. An instance method already runs on an object, and since there is one shared static variable per class, it can reach that too.

A final variable can be assigned exactly once. The compiler uses two flow checks: it makes sure a final is definitely assigned before you read it, and definitely UN-assigned (not yet set) before each assignment. Together these guarantee "assigned once, never reassigned."

Accidental shadowing makes you read or write the wrong variable, like a setter assigning a parameter to itself so the field never updates. Prevent it with this.field, clear names, and compiler warnings or linters.

A variable is visible only inside the block of curly braces where it is declared, plus any blocks nested inside it. If a local variable has the same name as a field, the local one wins inside that block; this is called shadowing.

No. var is not a type. It is only a way to tell the compiler 'figure out the type for me.' After compilation the variable has a normal concrete type, exactly as if you had typed it yourself, so there is no var type anywhere at runtime.

The compiler models control flow. A loop body might run zero times, so assignments inside it usually don't count as guaranteed. A catch block could be entered after an assignment in the try only partly ran, so the try's assignments aren't trusted in catch. Code that always returns, throws, or breaks doesn't need to reach the rest, so those paths are excluded.

A final instance field can be set at its declaration or inside every constructor, but exactly once. The compiler checks that by the time any constructor finishes, every final field has been assigned on all paths, and never twice. This is great for required, unchanging fields.

A local variable is effectively final if you never reassign it after its first value, even though you did not write the word final. Lambdas and anonymous classes can only use such variables, because they capture the value, not a live link to your method's variable.

A lambda cannot declare a parameter or local with the same name as a variable already in scope in the enclosing method; that is a compile error. Anonymous and local inner classes also capture effectively-final locals and cannot redeclare them.

Shadowing is a local or parameter hiding a same-named field in one scope. Field hiding is a subclass field hiding a superclass field of the same name. Overriding is about methods and is chosen at runtime. Only overriding is polymorphic.

A static variable is one shared copy for the whole program. If several threads change it at once you can get wrong results, and it can cause hard-to-test code and memory leaks because it stays alive for the whole run.

The compiler infers the type of the initializer expression. So var x = 5 is int, var s = "hi" is String, and var d = 3.0 is double. Whatever the right-hand side's type is, that becomes the variable's fixed type.

Use var when the type is obvious from the right-hand side, like var user = new User();. Avoid it when the type is unclear, like var x = doSomething();, because the reader can no longer see what x is.

Static parts run once when the class is first loaded, top to bottom. Then, every time you create an object, the instance fields and instance blocks run top to bottom, and finally the constructor body runs.

The check looks only at code structure, not at what values variables hold at runtime. Deciding the exact set of reachable states is impossible in general, so the language uses a simpler, conservative rule that may reject a few safe programs but never accepts an unsafe one. You add an explicit initializer to satisfy it.