Page History

...

In this noncompliant code example, the programmer expects that both print statements will print the value of alpha as a char—A. The first print statement prints A because the compiler applies rule 8 from the result type determination table to determine that the second and third operands of the conditional expression are, or are converted to, type char. However, the second print statement prints 65—the value of alpha as an int. The first matching rule from the table is rule 10. Consequently, the compiler promotes the value of alpha to type int. 

public class Expr {
  public static void main(String[] args) {
    char alpha = 'A';
    int i = 0;
    //* Other code. Value of i may change */
    boolean trueExp = ...true; // Some expression that evaluates to true
    System.out.print(trueExp ? alpha : 0); // prints A
    System.out.print(trueExp ? alpha : i); // prints 65
  }
}

The first print statement prints A because the compiler applies rule 8 from the result type determination table to determine that the second and third operands of the conditional expression are, or are converted to, type char. However, the second print statement prints 65—the value of alpha as an int. The first matching rule from the table is rule 10. Consequently, the compiler promotes the value of alpha to type int.

Compliant Solution

This compliant solution uses identical types for the second and third operands of each conditional expression; the explicit casts specify the type expected by the programmer.

public class Expr {
  public static void main(String[] args) {
    char alpha = 'A';
    int i = 0;
    boolean trueExp = ...true; // Some expression that evaluates to true
    System.out.print(trueExp ? alpha : ((char) 0)); // prints A
    // Deliberate narrowing cast of i; possible truncation OK
    System.out.print(trueExp ? alpha : ((char) i)); // prints A
  }
}

...

This noncompliant code example prints 100 as the size of the HashSet rather than the expected result (some value between 0 and 50). The combination of values of types short and int in the second argument of the conditional expression (the operation i-1) causes the result to be an int, as specified by the normal integer promotion rules. Consequently, the Short object in the third argument is unboxed into a short, which is then promoted into an int. The result of the conditional expression is then autoboxed into an object of type Integer. Because the HashSet contains only values of type Short, the call to HashSet.remove() has no effect. 

public class ShortSet {
  public static void main(String[] args) {
    HashSet<Short> s = new HashSet<Short>();
    for (short i = 0; i < 100; i++) {
      s.add(i);
      // Cast of i-1 is safe, because value is always representable
      Short workingVal = (short) (i-1);
      // ... other code may update workingVal

      s.remove(((i % 2) == 1) ? i-1 : workingVal);
    }
    System.out.println(s.size());
  }
}

The combination of values of types short and int in the second argument of the conditional expression (the operation i-1) causes the result to be an int, as specified by the integer promotion rules. Consequently, the Short object in the third argument is unboxed into a short, which is then promoted into an int. The result of the conditional expression is then autoboxed into an object of type Integer. Because the HashSet contains only values of type Short, the call to HashSet.remove() has no effect.

Compliant Solution

This compliant solution casts the second operand to type short, then explicitly invokes the Short.valueOf() method to create a Short instance whose value is i-1. Consequently, the second and third operands of the conditional expression both have type Short, and the remove() call has the expected result. 

public class ShortSet {
  public static void main(String[] args) {
    HashSet<Short> s = new HashSet<Short>();
    for (short i = 0; i < 100; i++) {
      s.add(i);
      // Cast of i-1 is safe, because value is always representable
      Short workingVal = (short) (i-1);
      // ... other code may update workingVal

      // Cast of i-1 is safe, because value is always representable
      s.remove(((i % 2) == 1) ? Short.valueOf((short) (i-1)) : workingVal);
    }
    System.out.println(s.size());
  }
}

Consequently, the second and third operands of the conditional expression both have type Short, and the remove() call has the expected result.

Writing the conditional expression as ((i % 2) == 1) ? (short) (i-1)) : workingVal also complies with this guideline because both the second and third operands in this form have type short. However, this alternative is less efficient because it forces unboxing of workingVal on each even iteration of the loop and autoboxing of the result of the conditional expression (from short to Short) on every iteration of the loop.

...