Operators

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.

With && and ||, Java checks the left side first and skips the right side if the answer is already known. false && X stays false without running X; true || X stays true without running X. This lets you safely null-check before using a value.

Operator precedence is the set of rules that decides which operators run first in an expression that has no parentheses. For example, * runs before +, so 2 + 3 * 4 is 14, not 20.

Relational operators are <, <=, >, >= and equality operators are == and !=. They compare two values and always produce a boolean: true or false.

It's a one-line if/else that produces a value. You write condition ? a : b: if the condition is true you get a, otherwise b. It's an expression, so its result can be assigned or returned.

When both operands are whole numbers, / drops the fraction and rounds toward zero, so 7/2 is 3 and -7/2 is -3. Dividing an integer by 0 throws an error; dividing a double by 0.0 gives Infinity or NaN.

Compound assignment automatically casts the result back to the variable's type, like b += 1 meaning b = (byte)(b + 1). That hidden cast can quietly chop or wrap a value — e.g. byte b = 127; b += 1; makes b -128 with no error.

<< moves bits left (filling zeros on the right), multiplying by powers of two. >> moves bits right keeping the sign (negatives stay negative). >>> moves bits right but always fills zeros on the left, ignoring the sign.

If the reference is null, instanceof always returns false (for any type). It never throws a NullPointerException. This makes it a safe combined null-and-type check.

Associativity decides the grouping when operators have the same precedence. Most operators group left to right (a - b - c is (a - b) - c). Assignment groups right to left, so a = b = 0 sets b to 0 first, then a.

For primitives, == checks if the two values are equal and the relational operators compare their size. If the two operands are different number types, the smaller one is converted up to the larger type before comparing.

For objects, == checks whether two variables point to the very same object (identity). .equals() checks whether two objects are meaningfully equal in content. Use .equals() for value comparison, like comparing the text of two Strings.

If one branch is a primitive (like int) and the other is a wrapper (like Integer), Java makes both numeric, so it unboxes the wrapper. If that wrapper is null, unboxing it throws a NullPointerException — even though you only have a number on the other side.

Both add 1 to the variable. The difference is the value the expression gives: ++x increments first and returns the new value; x++ returns the old value and then increments. Used alone on a line they behave the same.

Compound operators combine an operation with assignment: x += y means roughly x = x + y. Java has +=, -=, *=, /=, %=, and the bitwise/shift ones. They are shorthand and evaluate the left side only once.

% gives the remainder after division. In Java the result takes the sign of the left operand (the dividend), so -7 % 3 is -1, not 2. It also works on doubles: 5.5 % 2 is 1.5.

A final variable can be assigned only once. After that you can't reassign it. But final only locks the variable, not the object it points to — you can still change the object's contents through that reference.

Give each flag its own bit (1, 2, 4, 8...). Use | to turn a flag on, & with the mask to test it, &~ to turn it off, and ^ to flip it. One int can hold up to 32 flags.

Pattern matching lets you write if (obj instanceof String s). If the test passes, it automatically casts obj and binds it to a new variable s, so you skip the manual cast. It removes boilerplate and the chance of casting to the wrong type.

&& and || stop early (short-circuit): they skip the right side once the answer is known. & and | on booleans give the same true/false result but always evaluate BOTH sides. On integers, & and | are bitwise operators instead.

On two booleans, ^ is logical XOR (exclusive or): it is true when the two values are different, and false when they are the same. It's handy to test 'exactly one of these is true'.

Because == has higher precedence than &, Java reads it as flags & (MASK == 0), not (flags & MASK) == 0. The comparison runs first, which is almost never what you meant. Add parentheses: (flags & MASK) == 0.

Java picks one common type for the whole expression. With two different number types it usually promotes both to the wider one (for example int and double become double), so the ternary's result is that wider type — even on the branch that wasn't taken.

Use a ternary for short, simple value selection (assign or return one of two values). Avoid it for side effects or when nesting many conditions — that gets hard to read. For anything complex, an if/else is clearer.

Whole-number math wraps around silently when it gets too big (e.g. a huge int can suddenly go negative). Decimal math (double) can't represent some values exactly, so 0.1 + 0.2 isn't exactly 0.3. Use bigger types, Math.*Exact, or BigDecimal to stay safe.

Java evaluates the target's location (like the array reference and index) first and only once, then reads the old value, applies the operation with the right-hand side, and stores back. So a method used to pick the slot runs a single time.