1.7 Operators

Learning Objectives

•Apply arithmetic, relational, and logical operators correctly.
•Predict integer vs. floating-point division and modulo results.
•Explain operator precedence in a multi-operator expression.

Introduction

Operators combine values into new values. Java groups them into arithmetic (`+ - * / %`), relational (`== != < > <= >=`), logical (`&& || !`), and unary (`++ -- + - !`) categories, each with well-defined precedence and associativity rules that determine evaluation order in a compound expression.

Key Concepts

Integer division truncates: `7 / 2` is `3`, not `3.5`.

`%` gives the remainder: `7 % 2` is `1`.

`&&`/`||` short-circuit: the right-hand operand is skipped if the result is already determined by the left.

Precedence: unary > multiplicative (`* / %`) > additive (`+ -`) > relational > equality > logical AND > logical OR.

Java Syntax

Code Examples

`a / b` performs integer division since both operands are `int`. `a % b` computes the remainder. The logical expression evaluates both relational comparisons and combines them with `&&`.

Common Mistakes

⚠Expecting `7 / 2` to produce `3.5` when both operands are `int` — it truncates to `3` because integer division is used.
⚠Using `&` or `|` (non-short-circuit) where `&&`/`||` were intended, causing both sides to always evaluate even when unnecessary or unsafe.
⚠Misjudging precedence in expressions like `a + b == c && d`, and omitting parentheses that would make intent explicit.

Practice

Practice 1

Short Answermedium

What does `int result = 9 % 4;` store in `result`?

Practice 2

Multiple Choicemedium

Which operator short-circuits, skipping its right operand when the left already determines the result?

Summary

Java's arithmetic, relational, and logical operators follow standard precedence rules. Integer division truncates, and `&&`/`||` short-circuit — both are frequent sources of subtle bugs if forgotten.

Previous TopicNext Topic