char, boolean, casting and conversions

Java converts between numeric types in two directions. A widening conversionwidening conversion: A conversion to a type that holds every value of the old one, such as int to long or char to int, which Java applies on its own. Between integer types it never changes the value; int or long to float and long to double can round., such as int to long or char to int, goes to a type whose range covers every value of the old one, so Java applies it on its own. A narrowing conversionnarrowing conversion: A conversion to a type that may not hold the value, such as int to byte or double to int. It needs a cast: integers keep their lowest bits, and floating-point values are cut toward zero and clamped to the range. goes the other way and needs a castcast: An explicit conversion written as (type) value, such as (byte) 200 or (int) 3.99. A cast between primitive types never throws, even when the value changes: (byte) 200 is -56., such as (byte) 200 or (int) 3.99, because the value may change: integers keep only their lowest bits, so (byte) 200 is -56, and floating-point values lose their fraction, so (int) 3.99 is 3.

Two types need their own rules. A char is a number, the 16-bit UTF-16 code of a character, so 'a' + 1 is the int 98. A boolean is not a number at all, and no cast turns it into one. You will run every kind of conversion on JDK 25, step through the bits a cast keeps and the cast hidden inside +=, and finish by shifting letters with char arithmetic.

A char is a number

A char holds one UTF-16 code unitUTF-16 code unit: One 16-bit number of the UTF-16 encoding of text, the unit a Java char holds and String.length() counts. Most characters are one code unit; characters beyond the first 65,536, such as many emoji, take two., an unsigned number from 0 to 65,535. Most characters you type, Latin and Devanagari letters included, are one code unit each, so for them a char is simply the character’s code:

// A char is a number: the UTF-16 code of one character, from 0 to 65535.
void main() {
    char letter = 'a';
    IO.println("'a' + 1          = " + ('a' + 1));            // char + int is an int
    IO.println("(char) ('a' + 1) = " + (char) ('a' + 1));
    letter++;                                                 // ++ keeps the char type
    IO.println("after letter++   = " + letter);
    IO.println("codes of A, Z, a, 0: " + (int) 'A' + " " + (int) 'Z' + " " + (int) 'a' + " " + (int) '0');
    IO.println("'7' - '0'        = " + ('7' - '0'));          // a digit character to its value
    IO.println("'a' + 'b'        = " + ('a' + 'b'));          // two chars add up as numbers
    IO.println("\"\" + 'a' + 'b'   = " + ("" + 'a' + 'b'));   // after a String, + joins text
    char ka = 'क';
    IO.println(ka + " is " + Character.getName(ka) + ", code " + (int) ka + ", a letter: " + Character.isLetter(ka));
    String smile = "😀";
    IO.println(smile + " is " + smile.length() + " chars but " + smile.codePointCount(0, smile.length()) + " code point");
}

from session import run, version

version()
run("""
java Chars.java
java Booleans.java
!java BooleanErrors.java
""")

# openjdk version "25.0.4.1" LTS
$ java Chars.java
'a' + 1          = 98
(char) ('a' + 1) = b
after letter++   = b
codes of A, Z, a, 0: 65 90 97 48
'7' - '0'        = 7
'a' + 'b'        = 195
"" + 'a' + 'b'   = ab
क is DEVANAGARI LETTER KA, code 2325, a letter: true
😀 is 2 chars but 1 code point
$ java Booleans.java
empty: false, ready: true
as a number: 1
parseBoolean: true false false
$ java BooleanErrors.java
BooleanErrors.java:3: error: incompatible types: int cannot be converted to boolean
    if (items) {                  // an int is not a condition
        ^
BooleanErrors.java:6: error: incompatible types: int cannot be converted to boolean
    boolean ready = 1;            // 1 is not true
                    ^
BooleanErrors.java:7: error: incompatible types: boolean cannot be converted to int
    int flag = (int) ready;       // and no cast turns a boolean into a number
                     ^
3 errors
error: compilation failed
[exit status 1]

• 'a' + 1 is the int 98: arithmetic turns a char into an int first. Cast the result back, (char) ('a' + 1), to get the character b.
• letter++ keeps the type: increment and decrement operators, like compound assignment below, convert the result back to the variable’s type.
• '7' - '0' is 7, because the digit characters have consecutive codes, 48 to 57. Character.getNumericValue does the same for digits of other scripts too.
• 'a' + 'b' adds two codes and prints 195. Once a String stands on the left, + joins text instead, so "" + 'a' + 'b' is "ab".
• 'क' is a Devanagari letter with the code 2325, and Character.isLetter knows it. Since JDK 18 Java reads source files as UTF-8 by default, so such letters can stand in the code as they are.
• The emoji 😀 is outside the first 65,536 code points, so it takes two char values, a surrogate pairsurrogate pair: Two UTF-16 code units, a high one from D800 to DBFF and a low one from DC00 to DFFF, that together encode one character beyond U+FFFF, such as an emoji. length() counts both; codePointCount counts one.: length() counts code units, codePointCount counts characters. A later lesson on Unicode covers this properly.

The codes the run printed follow a pattern worth knowing by heart:

A boolean is not a number

boolean has exactly two values, true and false, and Java has no conversion between it and any number. A condition must be a boolean, so the C habit of if (count) does not compile, and neither does boolean ready = 1 or a cast such as (int) ready. The last command of the session above shows all three errors, and each has a direct way to say what was meant:

Booleans come from comparisons and logic: items == 0 and !empty && items < 10 are boolean expressions. When you need 1 or 0, say so with the conditional operator, ready ? 1 : 0. Boolean.parseBoolean returns true only for the text “true” in any mix of upper and lower case; “yes”, “1” and null all give false.

Widening happens on its own

Java applies a widening conversion wherever one is needed: in an assignment, when passing an argument, and inside an expression. The diagram shows every widening path: follow the arrows from a type to the types it widens to.

Widening never throws, and between integer types it never changes the value. Three widenings can still round, the dashed arrows of the diagram, because a float has 24 significant bits and a double 53:

// Widening conversions happen on their own; three of them can round the value.
void main() {
    byte small = 100;
    int i = small;                // byte to int
    long l = i;                   // int to long
    double d = l;                 // long to double
    char c = 'A';
    int code = c;                 // char to int
    IO.println(i + " " + l + " " + d + " " + code);

    int big = 16_777_217;         // 2 to the power 24, plus 1
    float f = big;                // int to float compiles, but a float has 24 bits of precision
    IO.println(big + " as a float = " + f + ", back to int = " + (int) f);

    long huge = 9_007_199_254_740_993L;   // 2 to the power 53, plus 1
    double asDouble = huge;               // long to double: 53 bits of precision
    IO.println(huge + " as a double, back to long = " + (long) asDouble);
}

from session import run, version

version()
run("""
java Widening.java
java Narrowing.java
""")

# openjdk version "25.0.4.1" LTS
$ java Widening.java
100 100 100.0 65
16777217 as a float = 1.6777216E7, back to int = 16777216
9007199254740993 as a double, back to long = 9007199254740992
$ java Narrowing.java
(byte) 200          = -56
(byte) 256          = 0
(byte) -129         = 127
(short) 70000       = 4464
(int) 3000000000L   = -1294967296
(char) 66           = B
(int) (char) -1     = 65535
(int) 3.99          = 3
(int) -3.99         = -3
(int) 1e10          = 2147483647
(int) Double.NaN    = 0
(byte) 300.7        = 44
200 in bits: 11001000, as a byte: -56
300 in bits: 100101100, as a byte: 44

16,777,217 is 2²⁴ + 1, which needs 25 significant bits, so as a float it becomes the nearest float, 16,777,216, and the cast back to int shows the change. 9,007,199,254,740,993, which is 2⁵³ + 1, loses its last bit the same way as a double. Most code never meets numbers that large, but IDs, time stamps in nanoseconds and money in the smallest unit can, so keep them in long and never send them through float or double.

Narrowing needs a cast

A conversion that can lose information must be asked for with a cast, (type) value. What it keeps depends on the source type. The second program of the session above, Narrowing.java, shows each case:

// Narrowing casts: integers keep their low bits, floating-point values are cut toward zero first.
void main() {
    IO.println("(byte) 200          = " + (byte) 200);
    IO.println("(byte) 256          = " + (byte) 256);
    IO.println("(byte) -129         = " + (byte) -129);
    IO.println("(short) 70000       = " + (short) 70_000);
    IO.println("(int) 3000000000L   = " + (int) 3_000_000_000L);
    IO.println("(char) 66           = " + (char) 66);
    IO.println("(int) (char) -1     = " + (int) (char) -1);
    IO.println("(int) 3.99          = " + (int) 3.99);
    IO.println("(int) -3.99         = " + (int) -3.99);
    IO.println("(int) 1e10          = " + (int) 1e10);
    IO.println("(int) Double.NaN    = " + (int) Double.NaN);
    IO.println("(byte) 300.7        = " + (byte) 300.7);
    IO.println("200 in bits: " + Integer.toBinaryString(200) + ", as a byte: " + (byte) 200);
    IO.println("300 in bits: " + Integer.toBinaryString(300) + ", as a byte: " + (byte) 300);
}

• Integer to a smaller integer: the low bits stay. 200 is 11001000 in binary. A byte keeps those 8 bits and reads them as a signed number, -56. 256 is 1 followed by eight zeros, so (byte) 256 is 0, and (short) 70000 keeps the low 16 bits, 4,464. The sign can flip either way: (byte) -129 is 127.
• Integer to char: also the low bits, read as unsigned. (char) -1 is the char 65,535.
• Floating point to an integer: cut toward zero, then clamp. (int) 3.99 is 3 and (int) -3.99 is -3. A value beyond the range becomes the nearest limit, so (int) 1e10 is 2,147,483,647, and NaN becomes 0.
• Floating point to byte, short or char: two steps. The value is cut to an int first, then narrowed as an integer: 300.7 becomes 300, and 300 as a byte is 44.

Step through the bits behind two of those lines, using the binary forms the last two lines of the run print:

None of these throws. When a value that does not fit is a bug, check first: Math.toIntExact throws for a long outside the int range, and Math.round rounds a double to the nearest long instead of cutting it.

The cast hidden in compound assignment

b += 300 is not the same as b = b + 300. A compound assignmentcompound assignment: An assignment operator such as +=, -= or *=: b += x means b = (T) (b + x), where T is the type of b, so the result is cast back to the variable's type, and narrowed without a warning. such as +=, -= or *= casts its result back to the type of the variable, so it compiles for a byte even when the result does not fit:

// A compound assignment casts its result back to the type of the variable.
void main() {
    byte b = 10;
    b += 300;                     // b = (byte) (b + 300): 310 does not fit, 54 is kept
    IO.println("byte 10 += 300   -> " + b);
    short s = 1000;
    s *= 1000;                    // 1,000,000 as a short
    IO.println("short 1000 *= 1000 -> " + s);
    int total = 5;
    total += 2.7;                 // total = (int) (5 + 2.7)
    IO.println("int 5 += 2.7     -> " + total);
    char c = 'a';
    c += 2;
    IO.println("char 'a' += 2    -> " + c);
    final byte x = 10;
    byte y = x + 20;              // a constant expression that fits: allowed
    IO.println("final byte x = 10; byte y = x + 20 -> " + y);
}

void main() {
    byte b = 10;
    b = b + 300;                  // b + 300 is an int
    byte x = 10, y = 20;
    byte z = x + y;               // so is x + y, even though 30 would fit
    char c = 'a';
    c = c + 1;                    // and c + 1
}

from session import run, version

version()
run("""
java Compound.java
!java CompoundErrors.java
javac -Xlint:lossy-conversions Compound.java
""")

# openjdk version "25.0.4.1" LTS
$ java Compound.java
byte 10 += 300   -> 54
short 1000 *= 1000 -> 16960
int 5 += 2.7     -> 7
char 'a' += 2    -> c
final byte x = 10; byte y = x + 20 -> 30
$ java CompoundErrors.java
CompoundErrors.java:3: error: incompatible types: possible lossy conversion from int to byte
    b = b + 300;                  // b + 300 is an int
          ^
CompoundErrors.java:5: error: incompatible types: possible lossy conversion from int to byte
    byte z = x + y;               // so is x + y, even though 30 would fit
               ^
CompoundErrors.java:7: error: incompatible types: possible lossy conversion from int to char
    c = c + 1;                    // and c + 1
          ^
3 errors
error: compilation failed
[exit status 1]
$ javac -Xlint:lossy-conversions Compound.java
Compound.java:4: warning: [lossy-conversions] implicit cast from int to byte in compound assignment is possibly lossy
    b += 300;                     // b = (byte) (b + 300): 310 does not fit, 54 is kept
         ^
Compound.java:10: warning: [lossy-conversions] implicit cast from double to int in compound assignment is possibly lossy
    total += 2.7;                 // total = (int) (5 + 2.7)
             ^
2 warnings

10 + 300 is 310, and the hidden cast to byte keeps its low 8 bits, 54. short 1,000 times 1,000 becomes 16,960 the same way, and total += 2.7 on an int drops the fraction. By default the compiler accepts all of these without a warning, so be careful with += on narrow types. Step through both forms side by side:

The errors in CompoundErrors.java come from numeric promotionnumeric promotion: The rule that converts the operands of an arithmetic operator to a common type before it computes: byte, short and char become at least int, so the sum of two bytes is an int, and an int and a long give a long.: the operands of +, -, * and the other arithmetic operators are promoted to at least int, so b + 300, x + y on two bytes and c + 1 on a char are all int, and an int does not go into a byte or a char without a cast. A constant expression is the exception: final byte x = 10; makes x + 20 a constant, 30, which the compiler knows fits, so byte y = x + 20; compiles.

javac can be asked to warn. The last command of the session compiles Compound.java with -Xlint:lossy-conversions, which flags b += 300 and total += 2.7, whose right-hand side would need a cast to be assigned to the variable. It says nothing about s *= 1000 or c += 2, whose constants fit, although the first one wraps. The lint is worth turning on in a build, but only a variable wide enough for the result prevents the wrap.

Practise: a Caesar shift

Write shift(text, k), which moves every letter from a to z and A to Z k places along the alphabet, wrapping round from z to a, and leaves every other character as it is. k may be negative or very large:

// Exercise: shift(text, k) moves every letter a to z and A to Z k places along the alphabet, wrapping round from z
// to a, and leaves every other character as it is; k may be negative or very large. Write it, then run this file:
// every check must say ok.
String shift(String text, int k) {
    return text;                  // replace this line
}

int failures = 0;

void check(String text, int k, String expected) {
    String got = shift(text, k);
    if (!got.equals(expected)) failures++;
    IO.println((got.equals(expected) ? "ok      " : "FAILED  ") + "shift(\"" + text + "\", " + k + ") = \"" + got + "\"");
}

void main() {
    check("abc", 1, "bcd");
    check("xyz", 3, "abc");
    check("Hello, World!", 13, "Uryyb, Jbeyq!");
    check("abc", -1, "zab");
    check("Java 25", 1_000_000, "Xojo 25");
    check("Java", -1_000_000, "Vmhm");
    check("Zebra", Integer.MAX_VALUE, "Wbyox");
    check("café, नमस्ते", 2, "eché, नमस्ते");
    IO.println(failures + " of 8 checks failed");
    if (failures > 0) System.exit(1);
}

As given, the method returns the text unchanged:

from session import run, version

version()
run("""
!java Caesar.java
""")

# openjdk version "25.0.4.1" LTS
$ java Caesar.java
FAILED  shift("abc", 1) = "abc"
FAILED  shift("xyz", 3) = "xyz"
FAILED  shift("Hello, World!", 13) = "Hello, World!"
FAILED  shift("abc", -1) = "abc"
FAILED  shift("Java 25", 1000000) = "Java 25"
FAILED  shift("Java", -1000000) = "Java"
FAILED  shift("Zebra", 2147483647) = "Zebra"
FAILED  shift("café, नमस्ते", 2) = "café, नमस्ते"
8 of 8 checks failed
[exit status 1]

First hint: reduce k first with Math.floorMod(k, 26) from the integer arithmetic lesson, then for a lowercase letter compute (char) ('a' + (c - 'a' + step) % 26). Adding k before reducing it overflows for Integer.MAX_VALUE, which the seventh check catches.

When the eight shifts all say ok, take the questions below on codes, booleans, widening, the bits a cast keeps and the cast inside +=. A question you get wrong returns at the end of the round, with its reasons:

Interview questions

Fresher · Why does byte b = 10; b = b + 1; fail to compile while b += 1; works?

In b + 1 both operands are promoted to int, so the sum is an int, and assigning an int to a byte is a narrowing conversion that needs a cast. A compound assignment is defined as b = (byte) (b + 1): it includes that cast, so it compiles, and it silently keeps only the low 8 bits when the result does not fit, so b += 300 turns 10 into 54. Write the cast yourself when narrowing is what you want, and use a wider variable when it is not.

Key takeaways

• A char is an unsigned 16-bit number: 'a' + 1 is the int 98, and (char) ('a' + 1) is 'b'.
• boolean never converts to or from a number; write flag ? 1 : 0, or count != 0, when you need one.
• Widening conversions (byte to short to int to long to float to double, and char to int) happen on their own; int or long to float and long to double can round.
• Narrowing needs a cast: integers keep their lowest bits, so the sign can change; floating-point values are cut toward zero and clamped to the range, and NaN becomes 0.
• Arithmetic promotes byte, short and char to int, and compound assignment such as += casts the result back, silently.