Operators, Expressions, Casting, and Scanner Input

Learning outcome: Build expressions, apply operators, predict precedence, cast values safely, and read typed input from the keyboard.

An expression is any combination of values, variables, and operators that produces a result.

int total = price * quantity + 50;

In this expression, price, quantity, and 50 are operands. The symbols * and + are operators.

Operator Families

Arithmetic Operators

The + operator also joins strings:

System.out.println("Age: " + 19);

Output:

Age: 19

Assignment and Compound Assignment

The assignment operator stores a value in a variable.

int x = 10;
x += 5;   // same as x = x + 5; result: 15
x -= 3;   // same as x = x - 3; result: 12
x *= 2;   // same as x = x * 2; result: 24
x %= 5;   // same as x = x % 5; result: 4

For ordinary examples these comments describe the result, but a compound assignment is not always identical to writing the expanded form: Java evaluates its left side once and performs an implicit cast back to the left-side type. For example, byte value = 10; value += 1; compiles, while value = value + 1; needs a cast because value + 1 has type int.

Common compound assignment operators:

Increment and Decrement

The ++ operator adds 1. The -- operator subtracts 1.

In simple terms: i++ hands over the value and then increases it; ++i increases first and then hands it over. On a line of its own the two are identical — inside a larger expression they are not.

Prefix changes the value before it is used. Postfix uses the old value first, then changes it.

int a = 5;
int b = a++;   // b gets 5, then a becomes 6
int c = ++a;   // a becomes 7, then c gets 7

System.out.println(a); // 7
System.out.println(b); // 5
System.out.println(c); // 7

Relational Operators

Relational operators compare two values and return a boolean.

In simple terms: These answer a yes-or-no question and produce a boolean. A single = assigns a value; a double == asks a question.

Example:

int marks = 65;
boolean passed = marks >= 40;

Use == for comparing primitive values. When comparing the content of strings, use .equals().

String a = "Java";
String b = "Java";

System.out.println(a.equals(b)); // true

Logical Operators

Logical operators combine boolean values.

In simple terms: && and || stop as soon as the answer is settled: if the left side of && is false, the right side is never evaluated. That short-circuit is what makes if (s != null && s.length() > 0) safe.

Example:

int age = 20;
int marks = 65;

boolean eligible = (age >= 18) && (marks >= 50);

&& and || short-circuit:

Bitwise Operators

Bitwise operators work on the individual bits of integral types (byte, short, int, long, and char, with smaller operands promoted to int). They are useful for low-level tasks such as flags and masks. The binary operators &, |, and ^ also accept boolean operands; unlike && and ||, they evaluate both sides.

Example with a = 6 (binary 0110) and b = 3 (binary 0011):

int a = 6;   // 0110
int b = 3;   // 0011

System.out.println(a & b);  // 2  -> 0010
System.out.println(a | b);  // 7  -> 0111
System.out.println(a ^ b);  // 5  -> 0101
System.out.println(~a);     // -7 (all bits flipped)

Shifting moves bits left or right:

System.out.println(6 << 1); // 12  -> multiply by 2
System.out.println(6 >> 1); // 3   -> divide by 2

With Boolean operands, && and || short-circuit, while & and | always evaluate both operands. With integral operands, &, |, and ^ operate on bits. There are no integral forms of && or ||.

Operator Precedence

When several operators appear in one expression, Java follows precedence rules. Higher-precedence operators are evaluated first.

In simple terms: Precedence is the order the language reads an expression, just as multiplication is read before addition in arithmetic. Brackets overrule it — and spare the next reader from having to guess.

Simplified precedence order:

When in doubt, use parentheses:

int a = 2 + 3 * 4;     // 14
int b = (2 + 3) * 4;   // 20

Type Conversion and Casting

Java sometimes needs to convert a value from one type to another.

In simple terms: Widening is pouring a small glass into a large one: nothing spills, and Java does it silently. Narrowing is the reverse, so Java makes you write the cast as a signed acknowledgement that you accept the spill.

There are two main cases:

1. Widening primitive conversion: a conversion Java permits implicitly, such as int to long or double.
2. Narrowing primitive conversion: a conversion such as double to int. It normally requires an explicit cast and may lose range or precision.

“Widening” is a language category, not a promise that every value remains exact. Converting an int or long to float, or a long to double, can lose low-order precision even though no cast is required. Also, char widens to int, long, float, or double; it does not widen to byte or short.

Widening Conversion

int i = 100;
double d = i;       // automatic: int to double

System.out.println(d); // 100.0

Narrowing Conversion

double pi = 3.99;
int n = (int) pi;   // explicit cast: double to int

System.out.println(n); // 3

Casting from double to int truncates the fractional part. It does not round.

This explains integer division:

System.out.println(7 / 2);          // 3
System.out.println((double) 7 / 2); // 3.5
System.out.println(7.0 / 2);        // 3.5

Scanner Input

Use Scanner to read values typed by the user.

import java.util.Scanner;

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

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

        System.out.print("Enter name: ");
        String name = sc.next();

        System.out.println(name + " is " + age + " years old.");
        sc.close();
    }
}

Common Scanner methods:

Scanner pitfall:

After nextInt() or nextDouble(), a newline may remain in the input buffer. If the next call is nextLine(), it may read that leftover newline as an empty line.

Fix:

int age = sc.nextInt();
sc.nextLine();             // consume leftover newline
String fullName = sc.nextLine();

Worked Example: Two-Number Calculator

import java.util.Scanner;

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

        System.out.print("Enter first number: ");
        int a = sc.nextInt();

        System.out.print("Enter second number: ");
        int b = sc.nextInt();

        System.out.println("Sum        = " + (a + b));
        System.out.println("Difference = " + (a - b));
        System.out.println("Product    = " + (a * b));

        if (b == 0) {
            System.out.println("Quotient   = undefined (division by zero)");
            System.out.println("Remainder  = undefined (division by zero)");
        } else {
            System.out.println("Quotient   = " + ((double) a / b));
            System.out.println("Remainder  = " + (a % b));
        }

        sc.close();
    }
}

Sample run:

Enter first number: 17
Enter second number: 5
Sum        = 22
Difference = 12
Product    = 85
Quotient   = 3.4
Remainder  = 2

Practice

Problem 1: Celsius to Fahrenheit

Read a Celsius temperature and convert it using:

F = C * 9 / 5 + 32

import java.util.Scanner;

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

        System.out.print("Enter temperature in Celsius: ");
        double c = sc.nextDouble();

        double f = c * 9 / 5 + 32;
        System.out.println(c + " C = " + f + " F");

        sc.close();
    }
}

Problem 2: Prefix vs Postfix

Predict the output:

public class IncDemo {
    public static void main(String[] args) {
        int a = 5;
        int b = a++;
        int c = ++a;

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
    }
}

Problem 3: Eligibility Check

import java.util.Scanner;

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

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

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

        boolean eligible = (age >= 18) && (marks >= 50);
        System.out.println("Eligible to apply? " + eligible);

        sc.close();
    }
}

Common Mistakes

Quick Check

1. What is the value of 2 + 3 * 4, and why?
2. After int a = 5; int b = a++;, what are a and b?
3. Is int to double widening or narrowing?
4. What does (int) 3.99 produce?
5. Why can nextLine() return an empty string after nextInt()?

Summary

Operators combine operands into expressions. Precedence decides the order of evaluation, and parentheses make intent clear. Widening conversions are automatic, narrowing conversions require a cast, and Scanner lets Java programs read typed input from the keyboard.