> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Conditional OR The `||` (Conditional-OR) operator is a binary logical operator in Java that evaluates two `boolean` expressions and returns `true` if at least one of the operands evaluates to `true`. It is strictly a boolean operator and is characterized by its short-circuit evaluation mechanism. ```java theme={"dark"} expression1 || expression2 ``` Both `expression1` and `expression2` must resolve to a primitive `boolean` or the `Boolean` object wrapper. The operator returns a primitive `boolean`. If an operand is a `Boolean` object wrapper, Java performs implicit unboxing. If the wrapper reference is `null`, this implicit unboxing process will throw a `NullPointerException` at runtime. ## Evaluation Mechanics The operator follows standard boolean logic for an inclusive OR operation: * `true || true` yields `true` * `true || false` yields `true` * `false || true` yields `true` * `false || false` yields `false` ## Short-Circuit Evaluation The defining technical characteristic of the `||` operator is short-circuiting. Operands are evaluated from left to right. If the left operand (`expression1`) evaluates to `true`, the overall result of the operation is guaranteed to be `true` regardless of the right operand's value. When this occurs, the evaluation of the right operand (`expression2`) is completely bypassed. ```java theme={"dark"} boolean result = (x == 10) || (y++ > 5); ``` In the syntax above, if `(x == 10)` evaluates to `true`, the expression `(y++ > 5)` is never executed, meaning the variable `y` will not be incremented. The right operand is evaluated *only* if the left operand evaluates to `false`. ## Precedence and Associativity * **Associativity:** Left-to-right. Multiple `||` operators in a single statement are evaluated starting from the leftmost operator. * **Precedence:** The `||` operator has a relatively low precedence in Java's order of operations. It ranks lower than relational operators (`<`, `>`, `<=`, `>=`), equality operators (`==`, `!=`), bitwise operators (`&`, `^`, `|`), and the Conditional-AND operator (`&&`). It ranks higher than the ternary operator (`? :`) and assignment operators (`=`, `+=`). Because `&&` has higher precedence than `||`, mixed logical expressions are evaluated with AND operations binding tighter than OR operations: ```java theme={"dark"} boolean result = expr1 || expr2 && expr3; ``` The Java compiler (`javac`) applies precedence rules during compilation to parse the syntax as: ```java theme={"dark"} boolean result = expr1 || (expr2 && expr3); ``` ## Distinction from the Bitwise OR (`|`) While both `||` and `|` can operate on boolean values, the single pipe `|` is the Bitwise/Logical Inclusive OR operator. When applied to booleans, `|` performs a full evaluation of both operands, explicitly disabling short-circuit behavior. The `||` operator is strictly for boolean logic and cannot be used for bitwise manipulation of integer types.

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More