ICSE Class 9 Java Operators – Quick Guide

Why Java Operators Matter

Ever wondered how a calculator knows to add two numbers or how a game decides if a player wins? That magic happens thanks to operators – the tiny symbols that tell Java what to do with values.

💡 In Simple Words: Operators are like the verbs in a sentence. They tell the computer to add, compare, or change numbers and variables, just like "run" tells you to move fast.

What Are Operators?

In Java, an operator is a special symbol (or a few symbols together) that performs an operation on one or more operands – the values or variables you give it. Think of it as a kitchen gadget: a whisk (operator) mixes eggs (operands) to make a batter.

1. Arithmetic Operators – the math toolbox

These do basic math, just like the keys on a calculator.

• + – addition (adds two numbers). Example: int sum = a + b;
• - – subtraction (takes one number away from another). Example: int diff = a - b;
• * – multiplication. Example: int prod = a * b;
• / – division. Example: int quot = a / b; // integer division
• % – modulus (gives the remainder). Example: int rem = a % b;

Remember: If you divide two int values, Java drops any decimal part. Use double if you need fractions.

2. Relational (Comparison) Operators – checking conditions

These compare two values and give back a boolean – either true or false. It’s like asking “Is this number bigger than that one?”

Use these in if statements, loops, or anywhere you need a true/false decision.

3. Logical Operators – combining true/false statements

When you have more than one condition, logical operators help you join them, just like “and” or “or” in everyday language.

• && – logical AND. Both sides must be true. Example: if (a > 0 && b > 0) …
• || – logical OR. At least one side true. Example: if (a > 0 || b > 0) …
• ! – logical NOT. Flips true to false and vice‑versa. Example: if (!isReady) …

These are the backbone of decision‑making in any Java program.

4. Assignment Operators – putting values into variables

The basic assignment operator is =. It copies the right‑hand value into the left‑hand variable.

Java also lets you combine arithmetic with assignment, saving a step:

• += – add then assign. a += 5; is the same as a = a + 5;
• -= – subtract then assign.
• *=, /=, %= – similar shortcuts for other arithmetic operators.

5. Unary Operators – single‑operand tricks

These work on just one operand.

• + and - as sign operators (e.g., -a makes a negative).
• ++ – increment (adds 1). a++ returns the old value then adds 1; ++a adds first then returns.
• -- – decrement (subtracts 1). Works similarly to ++.

Remember the difference between post‑ and pre‑increment when using them inside larger expressions.

6. Bitwise Operators – working with binary digits

These treat numbers as strings of 0s and 1s. They’re handy in low‑level tasks like setting flags.

• & – bitwise AND.
• | – bitwise OR.
• ^ – bitwise XOR (exclusive OR).
• ~ – bitwise NOT (flips bits).
• << – left shift (moves bits left, multiplying by 2).
• >> – right shift (divides by 2, discarding remainder).

For most ICSE exams, you only need to recognise the symbols and know a simple example.

Quick Comparison of Operator Categories

📝 Likely Exam Questions

1. Write the output of the following code:

   int a = 5; int b = 2; System.out.println(a % b);

   Answer: 1 because 5 divided by 2 leaves a remainder of 1.
2. Explain the difference between == and = in Java.
   Answer: == checks if two values are equal (produces a boolean), while = assigns the right‑hand value to the left‑hand variable.
3. What will be printed?

   int x = 10; System.out.println(x++); System.out.println(++x);

   Answer: First line prints 10 (post‑increment returns old value). After that, x becomes 11. The second line prints 12 because ++x increments first.
4. Combine relational and logical operators to test if a number n is between 10 and 20 (inclusive).
   Answer: if (n >= 10 && n
5. Give one example of a bitwise operator and a situation where it might be useful.
   Answer: int mask = 0b00001111; int result = value & mask; – the AND operator keeps only the lower four bits, useful for extracting a nibble from a byte.