> ## 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.
# Kotlin Logical AND
The `&&` operator is the logical AND operator in Kotlin. It performs a strict boolean conjunction, evaluating to `true` if and only if both its left and right operands evaluate to `true`. If either operand is `false`, the entire expression evaluates to `false`.
```kotlin theme={"dark"}
val result = expression1 && expression2
```
## Technical Characteristics
**Type Constraints**
Both operands provided to the `&&` operator must resolve to the `Boolean` type. The resulting evaluation also strictly returns a `Boolean`. Kotlin does not support implicit truthiness (e.g., evaluating non-zero integers or non-empty strings as true); operands must be explicit booleans.
**Short-Circuit Evaluation**
Kotlin implements short-circuit (lazy) evaluation for the `&&` operator. The evaluation proceeds strictly from left to right. If the left-hand operand evaluates to `false`, the overall expression is mathematically guaranteed to be `false`. In this scenario, the Kotlin compiler entirely bypasses the evaluation of the right-hand operand.
```kotlin theme={"dark"}
// If `conditionA` is false, `functionB()` is never executed.
val result = conditionA && functionB()
```
This behavior is structurally critical as it prevents side effects, state mutations, or runtime exceptions (such as `NullPointerException` or `IndexOutOfBoundsException`) that might otherwise occur if the right-hand expression were forced to evaluate.
**Operator Precedence**
In Kotlin's hierarchy of operations, the `&&` operator is evaluated after most other operators, but before logical OR and assignment. Specifically, its precedence is:
* **Lower than:** Logical NOT (`!`), comparison operators (`<`, `>`, `<=`, `>=`), and equality operators (`==`, `!=`).
* **Higher than:** Logical OR (`||`) and assignment operators (`=`, `+=`, etc.).
```kotlin theme={"dark"}
// Evaluated as: (!isReady) && (count > limit)
val result = !isReady && count > limit
```
**No Operator Overloading**
Unlike many mathematical and structural operators in Kotlin (such as `+`, `-`, or `==`), the `&&` operator **cannot** be overloaded. Because short-circuiting dictates control flow rather than just value transformation, the compiler must maintain absolute control over its execution path.
If strict evaluation of both operands is required regardless of the left operand's state, Kotlin provides the `and` infix function (`Boolean.and(Boolean)`), which performs a logical AND without short-circuiting.
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
