Java Language Fundamentals

A block is code wrapped in curly braces { }. It groups statements together. A variable you declare inside a block can only be used inside that block; once the block ends, the variable is gone.

Java has three: single-line starting with //, multi-line wrapped in /* ... /, and Javadoc written as /* ... */ which is a documentation comment the javadoc tool reads. All of them are ignored by the compiler.

Rules are what the compiler enforces; conventions are agreed style. By convention: classes use UpperCamelCase, variables and methods use lowerCamelCase, constants use UPPER_SNAKE_CASE, and packages are all lowercase. Breaking a convention still compiles, but it's bad style.

A Java identifier can contain letters, digits, the dollar sign ($), and the underscore (_). It can start with a letter, $, or _, but it cannot start with a digit.

Keywords are words Java reserves for its own grammar (like class, if, return, int). The compiler treats them specially, so you can't use them to name your own variables, methods, or classes.

Uninitialized fields get a default automatically: 0 for number types, false for boolean, '' (the null character) for char, and null for any object/reference type. You don't have to set them yourself.

Local variables don't get default values. The compiler requires you to assign a value before reading one, so it rejects the code with 'variable x might not have been initialized'. A field would instead default to 0.

A literal is a fixed value written directly in source code, like 42, 3.14, 'A', "hello", true, or null. Java has integer, floating-point, character, string, boolean, and the null literal.

Java does not throw an error. The value silently wraps around: adding 1 to the largest int gives the smallest (most negative) int. No warning, no exception.

Uninitialized primitive fields get defaults: 0 for numbers, 0.0 for float/double, '' for char, false for boolean. Local variables get NO default — you must assign before use or the code won't compile.

Definite assignment is a compile-time check that every local variable is given a value before you read it. If the compiler can find any path where the variable might not be set yet, it refuses to compile and reports a "variable might not have been initialized" error.

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.

Java has +, -, *, / and % for add, subtract, multiply, divide, and remainder. There are also unary + and - that keep or flip a number's sign.

The = operator stores the value on its right into the variable on its left. An assignment is also an expression whose result is the value that was assigned, so you can write a = b = 5 and both become 5.

&, |, ^ compare two numbers bit by bit (AND, OR, XOR); ~ flips every bit. They work on whole numbers. && and || work on true/false, only look at the second value if needed, and give back true or false.

instanceof checks whether an object is an instance of a given type (class or interface). It returns a boolean: true if the object's type matches that type or a subtype, otherwise false.

&& is logical AND: true only if both sides are true. || is logical OR: true if at least one side is true. ! is NOT: it flips a boolean, turning true into false and false into true.

Autoboxing is the automatic conversion of a primitive (like int) to its wrapper object (Integer). Unboxing is the reverse. The compiler inserts these conversions for you when a primitive is used where an object is expected, or vice versa.

When you do arithmetic on two numbers, Java converts both to a common type before computing. Anything smaller than int (byte, short, char) becomes int first. So byte + short gives an int.

Widening turns a smaller numeric type into a bigger one, like int to long or int to double. Java does it automatically because the bigger type can always hold the value, so no data is lost.

Upcasting treats an object as one of its parent types and happens automatically. Downcasting treats it as a more specific child type and must be written explicitly with a cast like (Dog) animal.

Wrapper classes like Integer, Long, Double, Boolean, and Character are object versions of the eight primitive types. They exist because generics and collections only hold objects, not primitives, and they add helper methods and constants.

break stops the loop entirely and jumps to the code right after it. continue skips the rest of the current iteration and goes straight to the next one (re-checking the loop condition).

It is a shorter loop for going through every element of an array or collection without a counter. You write 'for (Type item : collection)' and 'item' takes each value in turn.

A for loop has three parts in parentheses, separated by semicolons: initialization, condition, and update. Init runs once first; then each pass checks the condition, runs the body, then runs the update.

An if statement runs a block of code only when its condition is true. An optional else block runs when the condition is false. The condition must be a boolean.

An else-if chain tests conditions in order from top to bottom. The first condition that is true runs its block, and the rest are skipped. An optional final else catches everything else.