Operators

The shift amount is reduced using a remainder. For int it's the amount mod 32, for long it's mod 64. So 1 << 33 is the same as 1 << 1 = 2, not 0.

byte, short, and char are widened to int before any bitwise or shift operation. A negative byte gets its high bits filled with 1s (sign extension), so masking with & 0xFF is often needed to get the value you expect.

If the compiler can prove the test could never possibly be true — because the two types have no possible relationship — instanceof is a compile error, not a false result. It also won't compile with a primitive on the left.

Chains of instanceof checks scatter type-specific logic and must be edited every time a new subtype is added. Prefer polymorphism (an overridden method on each type) so each type owns its behavior. For closed sets, sealed types + pattern-matching switch give safe, exhaustive handling.

Because && and || stop early, the order of checks matters: put guards (like null checks) and cheap, likely-decisive tests first so the expensive or unsafe ones run only when needed. The pitfall is hiding required side effects inside an operand that may get skipped.

Precedence decides how operators group their operands; evaluation order decides which operand runs first in time. In Java operands always run left to right, no matter the precedence, so a higher-precedence operator can still have its operands computed later.

Integer is an object, so == compares references, not the number. Java caches small boxed values (-128 to 127), so two boxed ints in that range can share one object and be == ; outside that range they are different objects and == is false. Always use .equals() or unbox to int.

Relational operators (<, >) only work on numbers, not objects. To order objects you implement Comparable's compareTo (or pass a Comparator) and check whether its result is negative, zero, or positive.

For object branches, Java finds a common parent type both branches share — roughly their nearest shared supertype. If one branch is null, the result takes the other branch's type. The result is the most specific type that can hold either value.

Let obvious arithmetic precedence stand (a * b + c), but require parentheses whenever you mix different operator families — especially bitwise with comparison, or assignment/ternary in chains. Back it with linter rules so it's automatic, not memory.