Operators and expressions

The divide operator acts on two literals 8 an 9 of type int. Thus irrespective of the possibly intended floating point result 8 / 9 expression's type is int as well.

According to https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.1.3-300-A-2 the floating point value 0.88888... will be “rounded toward zero” yielding an int value of 0 rather than 1.

Conclusion: a = a + 1 and a++ surprisingly differ in behaviour when being applied to non-int variables.

The value 2147483647 is actually the largest possible int value Integer.MAX_VALUE. The plus operator in the first expression 2147483647 + 1 acts on two operands of type int. Thus the resulting sum will be of type int as well irrespective of its value.

On binary level adding an int value of 1 results in:

  01111111_11111111_11111111_11111111    2147483647
+ 00000000_00000000_00000000_00000001   +         1
-------------------------------------  ------------
  10000000_00000000_00000000_00000000   -2147483648

With respect to two-complement representation of signed int values this is actually an overflow error: There simply is no positive int value of 2147483648 in Java™. See http://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.1.3-220 for details.

On contrary the plus operator in the expression 2147483647 + 1L acts on an int to its left and a long to its right. The result will thus be of type long:

                                      01111111_11111111_11111111_11111111    2147483647
+ 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001   +         1
-------------------------------------------------------------------------  ------------
  00000000_00000000_00000000_00000000_10000000_00000000_00000000_00000000    2147483648

Due to a long's larger allocation of eight rather than four bytes execution reveals no overflow problem thus yielding the expected result.

The expression x == y evaluates to false. This surprising result is due to limited precision regarding both float and double IEEE representations: A given value will be approximated as close as possible.

Adding System.out.println(x - y) yields a value of -1.1102230246251565E-16 denoting the representational deviation of x and y.

Comparing float and double values thus requires providing a representational distance limit below which two values will be regarded as equal:

final double a = 0.7;
final double b = 0.9;
final double x = a + 0.1;
final double y = b - 0.1;
System.out.println(Math.abs(x - y) < 1.E-14);

The last line represents the boolean expression $\left|x-y\right|<{\mathrm{10}}^{-\mathrm{14}}$. So two values will be regarded as equal if their mutual distance is less than 0.00000000000001.

Considering short sum = 4 + 7 the plus operator acts on two int operands. The expression 4 + 7 is thus of type int (not short). Both operands are static i.e. their values are known at compile time rather than at run time. The 4 + 7 expression's value can thus be evaluated at compile time. The resulting value of 11 is within $\left[-2^{\mathrm{15}},-2^{\mathrm{15}}-1\right]$ so the compiler will safely assign 11 to the variable sum of type short without any information loss.

The expression a + 7 contains a variable “a” of type short to the plus operator's left and an int literal “7” to its right. Thus the expression is of type int as well. However a compiler will consider a's value to be unknown at compile time (albeit humans will safely assume a value of 4 by virtue of the preceding statement). Therefore a + 7 could potentially exceed a short's range of values and thus cannot be assigned to the variable sum in a safe manner.

A final variable's value cannot change. Thus the expression a + 7 is fully equivalent to 4 + 7 and can thus be evaluated at compile time. Like in the preceding Figure 122, “Constant expression assignment” code sample the resulting value of 11 neatly fits into the variable sum of type short.

The solution is straightforward. We just add a final modifier to the definition of our variable pi:

final ❶ double pi = 3.141592653589793;
...
pi = -4; ❷
...

As a rule of thumb: Whenever you intend a variable not to change after an initial assignment use final declaring it to remain constant.

In addition refactoring our variable pi using capital letters reflecting the naming convention for constants. This is does not change program execution in any way but enhances code readability:

final double PI = 3.141592653589793;
double radius = 2.3; // Computing a circle's area
System.out.println("A circle of radius " + radius + " will cover an area of " +
  PI * radius * radius);

PI = -4; // Compile time error

radius = 1.8;

System.out.println("A circle of radius " + radius + " will cover an area of " +
   PI * radius * radius);

A straightforward solution reads:

final short
  weeks = 2,
  days = 3,
  hours = 14,
  minutes = 32,
  seconds = 55;

final int secondsElapsed =
  seconds + 60 * minutes + 60 * 60 * hours + 60 * 60 *  24 * days + 60 * 60 *  24 * 7 * weeks;

System.out.println(secondsElapsed);

This requires four additions and 10 multiplications. Horner's rule allows for:

...
final int secondsElapsed =
  seconds + 60 * (minutes + 60 * (hours + 24 * (days + 7 * weeks)));
...

This still leaves us with four additions but just 4 instead of 10 multiplications.

Within the given context the difference in execution time can be neglected. But in a larger application the calculation in question might have to be repeated millions of times giving rise to a substantial gain with respect to execution time.

We extend the given minute calculation example to all 5 desired values:

final int secondsElapsed = 1521175;

int remaining = secondsElapsed;

final int seconds = remaining % 60;
remaining /= 60;          // Minutes

final int minutes = remaining % 60;
remaining /= 60;          // hours

final int hours = remaining % 24;
remaining /= 24;          // Days

final int days = remaining % 7;
final int weeks = remaining / 7;

System.out.println(weeks + ", " + days + ", " + hours + ", " + minutes + ", " + seconds);

The solution is straightforward using Math.PI:

double radius = 2.3; // Computing a circle's area
System.out.println("A circle of radius " + radius + " will cover an area of " +
  Math.PI * radius * radius);

public static void main(String[] args) {

  double temperatureCelsius = 23.2;

  double
      temperatureKelvin = temperatureCelsius + 273.15,
      temperatureFahrenheit = 9 * temperatureCelsius / 5 + 32;

  System.out.println("Celsius: " + temperatureCelsius);
  System.out.println("Kelvin: " + temperatureKelvin);
  System.out.println("Fahrenheit: " + temperatureFahrenheit);
}

We obtain the three year's compounded interest by:

Since we have not yet introduced loops the multiplication has to be repeated three times ❶:

// Interest parameters
final double initialCapital = 223.12;
final double interestRate = 1.5;

// Printing start values
System.out.println("Initial capital: " + initialCapital + '€');
System.out.println("Annual interest rate: " + interestRate + '%');
System.out.println("Interest period: 3 years");

// Calculations
final double annualSurplusFactor = (1 + interestRate / 100);
double finalCapital = initialCapital;

finalCapital *= annualSurplusFactor; ❶
finalCapital *= annualSurplusFactor; ❶
finalCapital *= annualSurplusFactor; ❶

// Printing result
System.out.println("Capital after three years: " + finalCapital);

We might as well use a single arithmetic expression achieving the same result:

...
final double
  annualSurplusFactor = 1 + interestRate/100,
  finalCapital = initialCapital * annualSurplusFactor * annualSurplusFactor * annualSurplusFactor;
...

Using loop statements our solution becomes more flexible with respect to the interest period in question:

// Interest parameters
final double initialCapital = 223.12;
final double interestRate = 1.5;
final int interestPeriodInYears = 3;

// Printing start values
System.out.println("Initial capital: " + initialCapital + '€');
System.out.println("Annual interest rate: " + interestRate + '%');
System.out.println("Interest period: " + interestPeriodInYears +
                  (interestPeriodInYears == 1? " year": " years"));

// Calculations
final double annualSurplusFactor = (1 + interestRate / 100);
double finalCapital = initialCapital;

for (int i = 0; i < interestPeriodInYears; i++) {
   finalCapital *= annualSurplusFactor;
}

// Printing result
System.out.println("Capital after three years: " + finalCapital);

In the section called “Interest calculations” we will present an even more elaborate solution based on classes.

Both short and char require two bytes in Java™. It is thus surprising that a mixed expression has got neither of both input types:

short s = 1;
char c = 'A';
short resultShort = s + c; // Incompatible types Required: short found: int
char resultChar= s + c;    // Incompatible types Required: char found: int

According to the compiler's error message the expression s + c is of type int. Why choosing a result type being twice the size of both input types?

The two input types have different ranges:

A promotion to int guarantees correct results in all circumstances.

Execution yields:

Exam success:false, points = 5

On modifying our code by registered && 4 <= points++ execution now results in:

Exam success:false, points = 4

The operators & evaluates both its left and right hand side expressions unconditionally. The right hand side expression 4 <= points++ thereby increases our variable points by one.

The & operator's left hand operand already carries a false value. From a logical point of view the “and” result will thus be false irrespective of the operator's right hand side. With respect to the logical result evaluating 4 <= points++ is a waste of time.

The && operator allows for precisely this shortcut: If its left hand side operand is already false the right hand side will not be evaluated hence retaining our points variable's value of 4. See 15.23. Conditional-And Operator && for further reference.

Likewise the || operator will only evaluate its right hand side if its left evaluates to false.