Operators and Expressions

// 1.1

Anatomy of an expression

An expression is a piece of code that Java can work out to a single value. It is built from operands (the values) and operators (the symbols that do something with them). Click any part of the line.

int total = price * count + 5;

// 1.2

The five arithmetic operators

You know four of them from school. The fifth, %, gets its own lab next. Remember from lesson 2: the types of the operands decide what / does.

int sum = 7;
int count = 2;
double avg = sum / count;
System.out.println(avg);
System.out.println((double) sum / count);

$ java Main
3.0
3.5

- and + also work with one operand: -x flips the sign. And dividing an int by zero crashes the program, while a double gives Infinity or NaN (lesson 2).

// 1.3

The remainder operator %

a % b is what is left over when you divide a by b in whole numbers. Change the numbers and watch the leftovers.

// 1.4

% at work

Backend code uses the remainder all the time: even and odd checks, digits of a number, time, and anything that wraps around.

int n = -7;
System.out.println(n % 2 == 0);  // even?
System.out.println(n % 2 == 1);  // odd? wrong
System.out.println(n % 2 != 0);  // odd? right

$ java Main
false
false
true

int n = 472;
System.out.println(n % 10);       // last digit
System.out.println(n / 10 % 10);  // middle digit
System.out.println(n / 100);      // first digit

$ java Main
2
7
4

int minutes = 125;
int h = minutes / 60;
int m = minutes % 60;
System.out.println(h + " h " + m + " min");

$ java Main
2 h 5 min

int hour = 22;
System.out.println((hour + 5) % 24);

$ java Main
3

// 1.5

Numeric promotion: what type is the result?

Before Java does arithmetic, it converts both operands to one common type. This is called numeric promotion, and two rules decide the type.

long wrong = 24 * 60 * 60 * 1000 * 365;
long right = 24L * 60 * 60 * 1000 * 365;
System.out.println(wrong);
System.out.println(right);

$ java Main
1471228928
31536000000

byte a = 10, b = 20;
byte c = a + b;
System.out.println(c);

$ javac Main.java
Main.java:4: error: incompatible types: possible lossy conversion from int to byte
        byte c = a + b;
                   ^
1 error

byte a = 10, b = 20;
int sum = a + b;
System.out.println(sum);
System.out.println('A' + 2);
System.out.println((char) ('A' + 2));
long big = 3_000_000_000L;
System.out.println(big + 1);

$ java Main
30
67
C
3000000001

// 1.6

+ with Strings

+ has two jobs. Between two numbers it adds. If either side is a String, it joins text, which is called concatenation. Java works from left to right, so where the String sits matters.

JShell shows Strings in quotes, so "33" is text and 33 is an int.

// 1.7

Useful Math methods

Java has no operator for powers or square roots. The built-in Math class has them, plus a few you will use every week.

// 1.8

Checkpoint: expressions and arithmetic

Eight questions on Part 1. Answer each one, read the explanation, and see your score at the end.

// 2.1

Assignment and compound operators

An assignment is an expression too: it stores a value and also has that value. And because adding to a variable is so common, Java has shortcuts for it.

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

$ java Main
5 5

// 2.2

The hidden cast in +=

x += y is not exactly x = x + y. It is x = (type of x) (x + y): the result is cast back to the type of x, silently.

$ javac Main.java
Main.java:6: error: incompatible types: possible lossy conversion from int to byte
        b = b + 5;
              ^
1 error

int x = 10;
x += 2.7;
System.out.println(x);
int n = 5;
n *= 2.5;
System.out.println(n);
short s = 32767;
s += 1;
System.out.println(s);

$ java Main
12
12
-32768

// 2.3

++ and --, step by step

x++ and ++x both add 1 to x. The difference is the value the expression gives: postfix x++ uses the old value, then changes. Prefix ++x changes first, then uses the new value. Step through it.

(output appears here)

// 2.4

Solving x++ + ++x

Lesson 2 ended with this puzzle. Java guarantees that the operands of + are evaluated from left to right, so the answer is always the same: 12. Step through it.

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

$ java Main
5

// 2.5

Game: predict x and y

Each snippet runs inside main. When it finishes, what are x and y? Work it out on paper before you click.

// 2.6

Checkpoint: assignment, ++ and --

Eight questions on Part 2. Trace each one in your head, step by step.

// 3.1

Relational and equality operators

A comparison always gives a boolean: true or false. You can print it, store it in a variable, and soon (lesson 4) use it in an if.

int age = 20;
boolean isAdult = age >= 18;
System.out.println(isAdult);
System.out.println(age == 18);
System.out.println(age != 18);

$ java Main
true
false
true

int x = 3;
boolean ok = (x = 5);

Main.java:4: error: incompatible types: int cannot be converted to boolean
        boolean ok = (x = 5);
                        ^
1 error

boolean done = false;
System.out.println(done = true);
System.out.println(done);

$ java Main
true
true

int x = 5;
System.out.println(1 < x < 10);

$ javac Main.java
Main.java:4: error: bad operand types for binary operator '<'
        System.out.println(1 < x < 10);
                                 ^
  first type:  boolean
  second type: int
1 error

// 3.2

Mixed types and doubles

Before comparing two numbers, Java promotes them to a common type, exactly like in arithmetic (1.5). And doubles bring back the rounding errors from lesson 2.

System.out.println(7 == 7.0);
System.out.println('a' == 97);
System.out.println(10 / 4 == 2.5);
System.out.println(10 / 4.0 == 2.5);

$ java Main
true
true
false
true

double a = 0.1 + 0.2;
System.out.println(a == 0.3);
System.out.println(Math.abs(a - 0.3) < 1e-9);
System.out.println(Double.NaN == Double.NaN);

$ java Main
false
true
false

// 3.3

Comparing Strings: == or .equals?

A String variable holds a reference: where the object lives in memory (lesson 2). == compares the references. .equals compares the text. Click a comparison.

String a = "Baku";
String b = new String("Baku");
String c = "Baku";
System.out.println(a == b);
System.out.println(a.equals(b));
System.out.println(a == c);
System.out.println(a.equalsIgnoreCase("BAKU"));

$ java Main
false
true
true
true

// 3.4

Game: true or false?

Each expression is a boolean. Decide what Java gives, then read why.

// 3.5

Checkpoint: comparing values

Eight questions on Part 3.

// 4.1

AND, OR, NOT and XOR

Logical operators take booleans and give a boolean. Flip the switches, or click a row of the truth table.

boolean canEnter = age >= 18 && hasTicket;
boolean dayOff = isWeekend || isHoliday;
boolean canLogin = !isBlocked;

// 4.2

Short-circuit evaluation

&& skips its right side when the left side is false: the answer is already false. || skips its right side when the left side is true. This shortcut lets the left side guard the right one. Pick an expression and a value.

// 4.3

Precedence and De Morgan’s laws

! comes first, then &&, then ||, just like minus, times and plus in maths. And there are two laws for moving a ! into brackets.

System.out.println(true || false && false);
System.out.println((true || false) && false);

$ java Main
true
false

int age = 20;
boolean hasTicket = true;
boolean isBlocked = false;
boolean isAdult = age >= 18;
boolean canEnter = isAdult && hasTicket && !isBlocked;
System.out.println(canEnter);

$ java Main
true

// 4.4

Game: write the condition

Turn the requirement into Java. Exactly one option is right; the others compile but give the wrong answer for some values, or don’t compile at all.

// 4.5

Checkpoint: logical operators

Eight questions on Part 4.

// 5.1

The bit lab: & | ^ ~

Remember the 8 bits of a byte from lesson 2? The bitwise operators compare two numbers bit by bit, column by column. Click bits to change A and B, then pick an operator.

// 5.2

Shift operators: << >> >>>

A shift moves all 32 bits left or right by n places. Bits that fall off the end are lost. The highlighted bits are the ones that came in.

// 5.3

Where backend developers meet bits

One int can hold many yes/no flags, one per bit. That is how Linux stores file permissions, and how many systems store user roles and settings.

int color = 0xFF8800;
int red = (color >> 16) & 0xFF;
int green = (color >> 8) & 0xFF;
int blue = color & 0xFF;
System.out.println(red + " " + green + " " + blue);

$ java Main
255 136 0

// 5.4

Checkpoint: bits

Eight questions on Part 5. Write the bits on paper if it helps.

// 6.1

The precedence table

Precedence says which operator groups first: higher rows win. Associativity says what happens between operators on the same row. The highlighted rows are the ones you will use every day.

// 6.2

The expression stepper

Pick an expression and press Step. Each step highlights the next operation, says which rule chose it, and replaces it with its value.

// 6.3

Grouping is not the same as order

Precedence decides how an expression is grouped. It doesn’t mean the high-precedence part runs first. Java always evaluates the operands from left to right, and then applies the operators in the grouped order.

int i = 1;
int r = i++ + i * 10;
System.out.println(r);

$ java Main
21

// 6.4

Break it on purpose

Real mistakes with operators. Most are caught by javac, some only crash while the program runs, and the worst ones compile and run but give the wrong answer. Pick one to see what really happens.

// 6.5

Checkpoint: precedence and order

Eight questions on Part 6.

// 7.1

Key takeaways

1. An expression is operands joined by operators. Every expression has a value and a type, and even an assignment has a value.

2. int / int drops the decimals. % gives the remainder, and its sign follows the left operand: -7 % 3 is -1.

3. In arithmetic, byte, short and char become int, and the wider type wins. Overflow happens before widening, so write 24L * ….

4. + with a String joins text from left to right: 1 + 2 + "3" is "33", but "1" + 2 + 3 is "123".

5. x++ gives the old value, ++x the new one, and += hides a cast. Keep ++ on its own line.

6. Comparisons give booleans. Use == for primitives, .equals for Strings, and a small tolerance for doubles.

7. && and || short-circuit, so put the guard on the left. ! comes before &&, and && before ||.

8. Bit operators work on single bits, and ^ is XOR, not power. Precedence groups, operands run left to right, and brackets make it clear.

// 7.2

Check yourself

Twenty questions from the whole lesson. You see the answer right after you pick.

Your checkpoints

// 7.3

Homework

Tick items as you finish them. Your ticks are saved in this browser only.

// 7.4

int score = 78;
if (score >= 90) {
    System.out.println("A");
} else if (score >= 75) {
    System.out.println("B");
} else {
    System.out.println("C");
}
String result = score >= 50 ? "pass" : "fail";
System.out.println(result);