Primitive Numeric Type Promotion Tutorial

When the arithmetic operators (+,-,*,/,%) are used in an expression, Java implements a feature called numeric promotion. You can mix or match any of the numeric primitive data types in an expression. This can cause a problem when it comes time to assign the resulting value of the expression to the target variable. Consider the following:
byte b = 0, a = 6;
int i = 50;
b = a + i ; // this statement will cause an error - why?
Even though we know the result of a + i (56) will fit just fine into a byte data type, the rules of automatic type converions won't let that happen without type casting. In order to solve the problem Java created a new set of rules for type promotion.

  • The expression must be contained inside a pair of opening and closing parenthesis.
  • If any of the operands are type double then the result is promoted to double.
  • Otherwise, if any of the operands are type float, then the result is promoted to float.
  • Otherwise, if any of the operands are type long, then the result is promoted to long.
  • Otherwise, if any or all of the operands are type byte, short, char, or int then the result is promoted to int.
Basically it works like this:
(target variable of data type) (=) (cast of (target data type)) ((operand + operand))
b = (byte) (a + i); // all fixed now

The promotion rules apply to an expression that includes any of the arithmetic operators (+,-,*,/,%). The data types of the original variable declarations are not changed, promotion only applies to the operands and the result of the expression.

Open the command prompt (CMD - see the Getting Started ) and type in the following commands.

C:\Windows\System32>cd \
C:\>md Java
C:\>cd Java
C:\Java>md TypePromotion
C:\Java>cd TypePromotion

Copy and Paste, or type the following code into Notepad and be sure to save the file when you are done.

class TypePromotion {
	public static void main(String args[]) {
		byte b = 2;
		//b = b * b; // error, the result of  b * b was promoted to an int data type
		//b = (byte) b * b; // still an error, the expression b * b needs to be in parenthesis
		b = (byte) (b * b);
		System.out.println("b = " + b);

		short s = 130;
		char c = 'A';
		s = (short) (s / c);
		System.out.println("s = " + s);

		float f = 2.25F;
		int i = 5;
		f = (float) (f + i);
		System.out.println("f = " + f);

		s = 130;
		long L = 125;
		s = (short) (s % L);
		System.out.println("s = " + s);

		i = 25;
		double d = 12.5D;
		i = (int) (i - d); // remember, casting can result in data loss
		System.out.println("i = " + i);

Now switch back to the command prompt (CMD) and type in javac and press Enter.
Now type in java TypePromotion and press Enter.

C:\Java\TypePromotion>java TypePromotion
b = 4
s = 2
f = 7.25
s = 5
i = 12

Final thoughts

My tutorials on Primitive Numeric Type Conversions, Primitive Numeric Type Casting, and this tutorial all tie together. It is very helpful to have a solid grasp of how conversion, casting, promotion, and the arithmetic operators all correspond with each other. If this tutorial made complete sense then you are good to go. If not, I would recommend reviewing all three tutorials to obtain a better understanding.