Unit 3: Operators

Opening Hook — Operators Power India's Biggest Trading Platform

Learning Outcomes — Bloom's Taxonomy Mapped (12 Outcomes)

Concept Explanation — Java Operators from Scratch

Operators are the verbs of programming. Variables are nouns (data), but operators are what do things to that data — add, compare, combine, shift, assign. Java has the richest operator set of any mainstream language. Master them, and you can express any computation in clean, efficient code.

1. Arithmetic Operators

These are your basic math operators. Simple, but full of traps — especially integer division and modulus.

Java
public class ArithmeticDemo {
    public static void main(String[] args) {
        int buyPrice = 1500;    // Bought Infosys shares at ₹1500
        int sellPrice = 1750;   // Sold at ₹1750
        int qty = 10;

        int profit = (sellPrice - buyPrice) * qty;
        System.out.println("Total Profit: ₹" + profit);  // ₹2500

        // ⚠️ Integer division trap!
        System.out.println(10 / 3);       // 3, NOT 3.33!
        System.out.println(10.0 / 3);     // 3.3333... (one operand is double)

        // Modulus — check if year is leap year
        int year = 2024;
        if (year % 4 == 0) System.out.println(year + " is a leap year");
    }
}

2. Relational (Comparison) Operators

Relational operators compare two values and return true or false. They're the foundation of every if statement, every loop condition, and every filter.

Java
// Zerodha-style: Is the trade profitable?
double buyPrice = 2450.75;
double sellPrice = 2510.30;

System.out.println(sellPrice > buyPrice);    // true — profitable!
System.out.println(sellPrice == buyPrice);   // false
System.out.println(sellPrice != buyPrice);   // true
System.out.println(sellPrice >= 2500.0);     // true — above target

3. Logical Operators

Logical operators combine multiple boolean conditions. They're the glue that connects simple comparisons into complex business logic.

Java
// Zerodha margin check: Can the user place this order?
double balance = 50000;
double orderValue = 45000;
boolean isVerified = true;
boolean isBanned = false;

// AND: Both conditions must be true
if (balance >= orderValue && isVerified) {
    System.out.println("✅ Order placed!");
}

// OR: At least one discount applies
boolean isStudent = true;
boolean isMilitary = false;
if (isStudent || isMilitary) {
    System.out.println("🎁 Discount applied!");
}

// NOT: Flip the condition
if (!isBanned) {
    System.out.println("User is active");
}

4. Bitwise Operators

Bitwise operators work on individual bits (0s and 1s) of integers. They're used in system programming, cryptography, game development, and permission systems. If you've ever wondered how Unix file permissions (chmod 755) work — it's bitwise operators.

Java
public class BitwiseDemo {
    public static void main(String[] args) {
        int a = 5;  // Binary: 0101
        int b = 3;  // Binary: 0011

        System.out.println("a & b  = " + (a & b));   // 1  (0001)
        System.out.println("a | b  = " + (a | b));   // 7  (0111)
        System.out.println("a ^ b  = " + (a ^ b));   // 6  (0110)
        System.out.println("~a     = " + (~a));      // -6 (two's complement)
        System.out.println("a << 1 = " + (a << 1)); // 10 (1010)
        System.out.println("a >> 1 = " + (a >> 1)); // 2  (0010)

        // 🔐 Permission system (like Unix chmod)
        int READ = 4;    // 100
        int WRITE = 2;   // 010
        int EXECUTE = 1; // 001

        int userPerm = READ | WRITE;  // 110 = 6 (read + write)
        System.out.println("Has READ?  " + ((userPerm & READ) != 0));   // true
        System.out.println("Has EXEC?  " + ((userPerm & EXECUTE) != 0)); // false
    }
}

5. Assignment Operators

Assignment operators combine an arithmetic/bitwise operation with assignment — shorthand that makes code cleaner and less error-prone.

Java
// Running total — like adding items to a Flipkart cart
double cartTotal = 0;
cartTotal += 499.00;   // Added a book
cartTotal += 1299.00;  // Added earphones
cartTotal += 799.00;   // Added a T-shirt
cartTotal *= 0.9;      // 10% festival discount
System.out.println("Cart Total: ₹" + cartTotal);  // ₹2337.3

6. Unary Operators (++, -- Pre/Post)

Unary operators work on a single operand. The increment/decrement operators are the most confusing (and most tested) operators in Java.

Java
public class UnaryTricks {
    public static void main(String[] args) {
        // === BASIC DIFFERENCE ===
        int a = 5;
        int b = 5;
        System.out.println("a++ = " + (a++));  // Prints 5, THEN a becomes 6
        System.out.println("a   = " + a);      // Now a is 6
        System.out.println("++b = " + (++b));  // b becomes 6 FIRST, prints 6

        // === TRICKY EXAMPLE 1 ===
        int x = 10;
        int y = x++ + ++x;
        // Step 1: x++ → use 10, x becomes 11
        // Step 2: ++x → x becomes 12, use 12
        // y = 10 + 12 = 22
        System.out.println("y = " + y);  // 22
        System.out.println("x = " + x);  // 12

        // === TRICKY EXAMPLE 2 ===
        int m = 5;
        m = m++;
        // Post-increment: temp = 5, m becomes 6, then m = temp = 5
        System.out.println("m = " + m);  // 5! (NOT 6)

        // === TRICKY EXAMPLE 3 ===
        int p = 3;
        int q = p++ * 2 + ++p;
        // Step 1: p++ → use 3, p becomes 4
        // Step 2: ++p → p becomes 5, use 5
        // q = 3 * 2 + 5 = 11
        System.out.println("q = " + q);  // 11
    }
}

7. Ternary Operator (?:) and instanceof

Ternary Operator — One-line if-else

Syntax: result = (condition) ? valueIfTrue : valueIfFalse;

Java
// Zerodha P&L display
double pnl = -2500.50;
String status = (pnl >= 0) ? "✅ PROFIT" : "🔴 LOSS";
System.out.println(status);  // 🔴 LOSS

// Nested ternary — grade calculator
int marks = 78;
String grade = (marks >= 90) ? "A+"
             : (marks >= 75) ? "A"
             : (marks >= 60) ? "B"
             : (marks >= 40) ? "C"
             : "FAIL";
System.out.println("Grade: " + grade);  // Grade: A

instanceof Operator — Type Checking

Checks if an object is an instance of a particular class or interface. Essential for polymorphism and safe casting.

Java
String name = "Zerodha";
System.out.println(name instanceof String);  // true
System.out.println(name instanceof Object);  // true (String extends Object)

// Safe casting pattern
Object obj = "Hello Java";
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());  // HELLO JAVA
}

8. Operator Precedence Table (Complete)

When multiple operators appear in one expression, Java follows this precedence (highest first). Memorise the top 5 levels — they appear in every exam and interview.

Java
// Precedence in action — predict the output!
int result = 2 + 3 * 4;
// * has higher priority than +
// = 2 + (3 * 4) = 2 + 12 = 14 (NOT 20!)
System.out.println(result);  // 14

int r2 = 2 + 3 * 4 - 6 / 2;
// = 2 + (3*4) - (6/2) = 2 + 12 - 3 = 11
System.out.println(r2);  // 11

boolean check = 5 > 3 && 2 < 4 || 1 == 0;
// Step 1: (5 > 3)=true, (2 < 4)=true, (1 == 0)=false
// Step 2: true && true = true
// Step 3: true || false = true
System.out.println(check);  // true

9. Short-Circuit Evaluation

Java's && and || are short-circuit operators. They stop evaluating as soon as the result is determined:

• &&: If the first operand is false, the second is never evaluated (result is already false).

• ||: If the first operand is true, the second is never evaluated (result is already true).

Java
public class ShortCircuitDemo {
    public static void main(String[] args) {
        // === SHORT-CIRCUIT && ===
        int x = 5;
        // Second condition NEVER runs because first is false
        if (x > 10 && ++x > 5) {
            System.out.println("Inside if");
        }
        System.out.println("x = " + x);  // 5 (NOT 6! — ++x was skipped)

        // === SHORT-CIRCUIT || ===
        int y = 5;
        // Second condition NEVER runs because first is true
        if (y < 10 || ++y > 5) {
            System.out.println("Inside if");
        }
        System.out.println("y = " + y);  // 5 (NOT 6! — ++y was skipped)

        // === PRACTICAL USE: Null-safe check ===
        String name = null;
        // Without short-circuit: name.length() would throw NullPointerException!
        // With short-circuit: if name is null, .length() is never called
        if (name != null && name.length() > 0) {
            System.out.println("Name: " + name);
        } else {
            System.out.println("Name is null or empty");
        }

        // === NON-SHORT-CIRCUIT: & and | ===
        int z = 5;
        if (z > 10 & ++z > 5) {  // Single & — BOTH sides evaluated!
            System.out.println("Inside if");
        }
        System.out.println("z = " + z);  // 6 (++z WAS executed)
    }
}

Learn by Doing — 3-Tier Lab: Zerodha P&L Calculator

Java
import java.util.Scanner;

public class PnLCalculator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter buy price (₹): ");
        double buyPrice = sc.nextDouble();

        System.out.print("Enter sell price (₹): ");
        double sellPrice = sc.nextDouble();

        System.out.print("Enter quantity: ");
        int qty = sc.nextInt();

        // Arithmetic operators
        double totalBuy = buyPrice * qty;
        double totalSell = sellPrice * qty;
        double pnl = totalSell - totalBuy;
        double pnlPercent = (pnl / totalBuy) * 100;

        // Brokerage (Zerodha charges ₹20 or 0.03%, whichever is lower)
        double brokerage = Math.min(20, totalBuy * 0.0003);
        double netPnl = pnl - (brokerage * 2);  // Buy + Sell side

        // Ternary operator for status
        String status = (netPnl >= 0) ? "✅ PROFIT" : "🔴 LOSS";

        // Relational: Check if target hit
        boolean targetHit = pnlPercent >= 5.0;

        System.out.println("\n═══ TRADE SUMMARY ═══");
        System.out.println("Buy Value:   ₹" + totalBuy);
        System.out.println("Sell Value:  ₹" + totalSell);
        System.out.println("Gross P&L:   ₹" + pnl);
        System.out.println("Brokerage:   ₹" + (brokerage * 2));
        System.out.println("Net P&L:     ₹" + netPnl);
        System.out.printf("Return:      %.2f%%\n", pnlPercent);
        System.out.println("Status:      " + status);
        System.out.println("5% Target:   " + (targetHit ? "HIT ✅" : "NOT YET ❌"));

        sc.close();
    }
}

Problem Set — Syntax/Tracing + Programming + Industry + Interview

Part 1: Syntax & Tracing Questions (5 Questions)

int a = 5, b = 10;
int c = a++ + ++b - --a + b--;
System.out.println("c = " + c + ", a = " + a + ", b = " + b);

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

int x = 5, y = 10;
boolean result = (x > 10) && (++y > 10);
System.out.println("result = " + result + ", y = " + y);

int val = 2 + 3 * 4 - 6 / 2 + 7 % 3;
System.out.println(val);

int i = 2;
int j = i++ + i++ + ++i;
System.out.println("j = " + j + ", i = " + i);

Part 2: Programming Questions (8 Questions)

1. Simple Calculator: Write a Java program that takes two numbers and an operator (+, -, *, /, %) as input and displays the result. Handle division by zero.
2. Swap Without Temp: Swap two integers using (a) arithmetic operators and (b) XOR bitwise operator. Print before and after values.
3. Leap Year Checker: Using %, &&, || operators, determine if a given year is a leap year. Handle century years correctly.
4. Even/Odd using Bitwise: Check if a number is even or odd using the & bitwise operator instead of %.
5. Grade Calculator: Using nested ternary operators, convert marks (0–100) into grades: A+ (≥90), A (≥75), B (≥60), C (≥40), FAIL (<40).
6. Bit Counter: Count the number of 1-bits (set bits) in an integer using & and >> operators.
7. EMI Calculator: Calculate monthly EMI using the formula EMI = P * r * (1+r)^n / ((1+r)^n - 1). Use Math.pow() and all arithmetic operators.
8. Income Tax Calculator: Build a complete Indian income tax calculator (New Regime 2024) using relational, logical, ternary, and arithmetic operators.

Part 3: Industry-Style Questions (3 Questions)

1. Razorpay Transaction Validator: Write a program that validates a payment: amount must be > 0, ≤ 100000, user must be verified, and account must not be frozen. Use &&, ||, !, and ternary operators.
2. PhonePe Cashback Engine: Implement a cashback calculator: 5% for UPI, 2% for wallet, 10% for first-time users (use &&), capped at ₹100. Use Math.min() and ternary.
3. Zerodha Order Type Classifier: Given order flags using bitwise encoding (BIT_0=BUY/SELL, BIT_1=LIMIT/MARKET, BIT_2=INTRADAY/DELIVERY), decode the order type using & and display it.

Part 4: Interview Questions (3 Questions)

1. [TCS/Infosys] What is the output? System.out.println(10 + 20 + "Hello" + 30 + 40); — Explain the string concatenation vs addition rule.
2. [Amazon/Flipkart] Explain the difference between & and && with a code example showing when they produce different results.
3. [Google/Microsoft] Given an array of integers where every element appears twice except one, find the single element using XOR. Explain why a ^ a = 0 and a ^ 0 = a.

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Use (Q11–Q15)

Analyze / Trace (Q16–Q20)

Evaluate / Judge (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (8 Questions)

Long Answer Questions (3 Questions)

Java
public class AllOperatorsDemo {
    public static void main(String[] args) {
        // 1. Arithmetic
        System.out.println("15 / 4 = " + (15 / 4));      // 3
        System.out.println("15 % 4 = " + (15 % 4));      // 3

        // 2. Relational
        System.out.println("5 >= 5: " + (5 >= 5));       // true

        // 3. Logical
        System.out.println("T && F: " + (true && false)); // false

        // 4. Bitwise
        System.out.println("5 ^ 3 = " + (5 ^ 3));        // 6

        // 5. Assignment
        int x = 10; x += 5;
        System.out.println("x += 5: " + x);               // 15

        // 6. Unary
        int a = 5;
        System.out.println("a++: " + (a++));               // 5
        System.out.println("++a: " + (++a));               // 7

        // 7. Ternary
        String r = (x > 10) ? "Big" : "Small";
        System.out.println("Ternary: " + r);               // Big

        // 8. instanceof
        System.out.println("instanceof: " + ("Hi" instanceof String)); // true
    }
}

Java
public class PermissionSystem {
    // Permission flags
    static final int READ    = 4;  // 100
    static final int WRITE   = 2;  // 010
    static final int EXECUTE = 1;  // 001

    public static void main(String[] args) {
        // Grant permissions using OR
        int admin = READ | WRITE | EXECUTE;  // 111 = 7
        int user = READ | EXECUTE;            // 101 = 5
        int guest = READ;                     // 100 = 4

        // Check permission using AND
        System.out.println("Admin can write: "
            + ((admin & WRITE) != 0));  // true
        System.out.println("Guest can write: "
            + ((guest & WRITE) != 0));  // false

        // Revoke permission using AND + NOT
        admin = admin & ~EXECUTE;  // Remove execute: 110 = 6
        System.out.println("Admin after revoke exec: " + admin);

        // Toggle permission using XOR
        user = user ^ WRITE;  // Toggle write: 101→111 = 7
        System.out.println("User after toggle write: " + user);
    }
}

Lab Programs

All lab programs for this unit are covered in Section D (Learn by Doing). The 3-tier lab structure provides guided, semi-guided, and open-ended programming exercises using all operator types. Refer to Section D for:

• 🟢 Tier 1 — Basic P&L Calculator (Guided)
• 🟡 Tier 2 — Multi-Trade Portfolio Analyzer (Semi-Guided)
• 🔴 Tier 3 — Full Trading Simulator (Open Challenge)

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 1–2 weeks (if you complete the P&L calculator and list it on Fiverr/Internshala)

Chapter Summary & Code Tweet

Java
// Java Operators — The Complete Cheat Sheet 🚀
int a=10,b=3;
a+b-b*b/b%b;              // Arithmetic: + - * / %
a==b; a!=b; a>b; a<b;     // Relational: == != > < >= <=
true&&false; true||false; !true;  // Logical: && || !
a&b; a|b; a^b; ~a; a<<1; a>>1; // Bitwise
a+=5; a-=3; a*=2;           // Assignment
++a; a++; --a; a--;          // Unary (pre/post)
(a>b)?"Y":"N";                // Ternary
"hi" instanceof String;       // instanceof
// 🏆 m=m++ → m stays same. ++i before, i++ after!

Self-Assessment Checkpoint

✅ Unit 3 complete. MCQs: 30. Ready for Unit 4!

[QR: Link to EduArtha video tutorial — Java Operators Deep Dive]