عرض عملي: محوّل وحدات وتجاوز سعة العدد الصحيح

Written Explanation

The plan

You will work in five steps, running the program after each one:

1. Celsius to Fahrenheit (double).
2. Kilometres to miles (double, with a constant).
3. A price as whole cents (int).
4. The planned mistake: 5 / 2.
5. The deliberate overflow.

Create a file Converter.java with a class called Converter and a main method, as in BEG-008. After each step, compile with javac Converter.java, run with java Converter, and compare with the output shown. Your output should match; if the wording of a compiler message differs slightly, that is normal.

Before you start, say your prediction aloud for each step. Predicting first is the habit that makes you fast at debugging.

Step 1: Celsius to Fahrenheit

The formula is F = C * 9 / 5 + 32. A temperature has a fractional part, so use double (Lesson 2).

double celsius = 25.0;
double fahrenheit = celsius * 9 / 5 + 32;
System.out.println(celsius + " C = " + fahrenheit + " F");

Expected output: 25.0 C = 77.0 F. Check by hand: 25 times 9 is 225, divided by 5 is 45, plus 32 is 77. The order matters: because celsius is a double, celsius * 9 is a decimal multiplication, and / 5 is decimal division too.

A trap to try deliberately: write 9 / 5 * celsius + 32 instead. Both 9 and 5 are int, so 9 / 5 is integer division, 1, and the result is 57.0, not 77.0. The expression is evaluated left to right, so the integer division happens before the double ever joins in. A conversion factor with a fraction is safer as 9.0 / 5.0.

Step 2: Kilometres to miles, with a constant

One kilometre is about 0.621371 miles. That factor is a magic number unless we name it, and it never changes while the program runs, so it is a final constant (Lesson 4).

final double MILES_PER_KM = 0.621371;
double km = 10.0;
double miles = km * MILES_PER_KM;
System.out.println(km + " km = " + miles + " miles");

Expected output: 10.0 km = 6.21371 miles. The constant is in UPPER_SNAKE_CASE, the variables in camelCase. If you wrote MILES_PER_KM = 0.6; later, the compiler would stop you.

Step 3: money in whole cents

A price of 19.99 must not be a double (Lesson 2). Store it as 1999 cents in an int, and let the code name the unit:

int priceCents = 1999;
int quantity = 3;
int totalCents = priceCents * quantity;
System.out.println("Total: " + totalCents / 100 + "." + totalCents % 100);

Expected output: Total: 59.97. Here integer division is exactly what we want: 5997 / 100 is 59 whole units and 5997 % 100 is 97 cents. (This prints incorrectly for totals whose cents are below 10, such as 5905, which would show 59.5. Formatting numbers properly is a later topic. For now, choose test values with two-digit cents.)

Step 4: the planned mistake

Suppose you want half of 5:

int half = 5 / 2;
System.out.println("half = " + half);

Prediction: you probably expect 2.5. The output is half = 2. Both operands are int, so the division is an integer division and the fraction is dropped (Lesson 5). Note that the compiler did not complain: this is a wrong answer, not a syntax error. Fix it by making one operand a double and the variable a double:

double halfFixed = 5 / 2.0;
System.out.println("halfFixed = " + halfFixed);

Output: halfFixed = 2.5. Both steps were needed: changing only the variable (double half = 5 / 2;) would still give 2.0, because the integer division happens first.

Step 5: the deliberate overflow

Now cause the big surprise on purpose:

int biggest = Integer.MAX_VALUE;
int wrapped = biggest + 1;
System.out.println("biggest = " + biggest);
System.out.println("wrapped = " + wrapped);

Expected output:

biggest = 2147483647
wrapped = -2147483648

Why: an int has 32 bits. Integer.MAX_VALUE is the largest value they can hold, so adding 1 does not fit. Java does not warn. It keeps only the low 32 bits of the true result, which is the smallest int. The odometer rolled past its maximum and landed on the other end. Write that into a comment next to the lines, because the lab requires an explanation:

// Overflow: an int cannot go past 2147483647, so adding 1
// wraps around to the smallest int, -2147483648.

Putting it together

Here is the finished program, using final constants and var where the right side is a plain literal (Lesson 6), and an explicit type where it helps the reader:

public class Converter {
    public static void main(String[] args) {
        // Temperature: Celsius to Fahrenheit
        final double CELSIUS_TO_F_SCALE = 9.0 / 5.0;
        var celsius = 25.0;
        var fahrenheit = celsius * CELSIUS_TO_F_SCALE + 32;
        System.out.println(celsius + " C = " + fahrenheit + " F");

        // Distance: kilometres to miles
        final double MILES_PER_KM = 0.621371;
        var km = 10.0;
        var miles = km * MILES_PER_KM;
        System.out.println(km + " km = " + miles + " miles");

        // Money: whole cents, never double
        var priceCents = 1999;
        var quantity = 3;
        var totalCents = priceCents * quantity;
        System.out.println("Total: " + totalCents / 100 + "." + totalCents % 100);

        // Planned mistake and its fix
        int half = 5 / 2;                 // 2: both operands are int
        double halfFixed = 5 / 2.0;       // 2.5: one operand is double
        System.out.println(half + " vs " + halfFixed);

        // Deliberate overflow: an int cannot go past 2147483647, so
        // adding 1 wraps around to the smallest int, -2147483648.
        int biggest = Integer.MAX_VALUE;
        int wrapped = biggest + 1;
        System.out.println(biggest + " + 1 = " + wrapped);
    }
}

Output:

25.0 C = 77.0 F
10.0 km = 6.21371 miles
Total: 59.97
2 vs 2.5
2147483647 + 1 = -2147483648