Values and Data Types in Java — ICSE Class 10 Computer Applications

Here is a question that has quietly cost ICSE students marks for years. What does this print?

System.out.println(5 / 2);

If you said 2.5, you have just met the reason this unit exists. Java answers 2. Not because it cannot divide, but because you told it you were working with whole numbers and it took you at your word. Data types are not paperwork. They are the promise you make to the compiler about what kind of value a variable holds, and the compiler keeps that promise even when you wish it would not.

This unit is where Section A marks are won and lost in bulk. Almost every output-prediction question rests on a data type detail: an integer division, a char quietly turning into a number, a double printing 350.0 where you wrote 350. Get this unit right and those questions become free marks. Skim it and they stay a lottery.

Every program on this page was compiled and executed on JDK 11 before publication. The output shown under each one is what the machine actually printed.

Your Game Plan

1. Memorise the eight primitive types with their sizes before anything else. Eight names, eight sizes. Ten minutes of honest effort, and half this unit is done.
2. Learn the four ASCII anchors — ‘A’ is 65, ‘a’ is 97, ‘0’ is 48, space is 32. Everything else you can work out from these four.
3. Understand widening and narrowing as a picture — a small glass pouring into a big one needs no help; a big glass pouring into a small one needs your permission and spills.
4. Type the four programs. Then deliberately break one line and read the compiler error. Errors teach types faster than notes do.
5. Do the worksheet with answers hidden and write your prediction before revealing.

Where This Unit Sits in the ICSE Class 10 Syllabus

In the official CISCE syllabus for Computer Applications (subject code 86), the Class X course opens with Revision of Class IX Syllabus, and Values and Data types is the third item in that list. The Class IX scope names exactly what is examinable: character set, ASCII code, Unicode, escape sequences, tokens, constants and variables, data types, and type conversions.

↑ Back to top

The Character Set, ASCII and Unicode

A computer stores numbers. Only numbers. So before it can store the letter A, somebody has to agree on which number will stand for A. That agreement is a character set — a table matching characters to numeric codes.

ASCII was the old agreement: 7 bits, so 128 codes, enough for English letters, digits, punctuation and a few control characters. Four values from that table are worth committing to memory because every ASCII question is built from them:

Notice the gap between an uppercase letter and its lowercase partner is always 32. That single fact answers a whole family of questions, and it is why (char)('A' + 32) gives ‘a’.

ASCII’s problem is obvious the moment you leave English. There is no room in 128 codes for Devanagari, Tamil, Bengali, Arabic or Chinese. Unicode solved that by using a much larger code space and assigning a unique number to every character of virtually every writing system in the world. Java stores a char in 16 bits precisely because it uses Unicode rather than ASCII, and the first 128 Unicode values are deliberately identical to ASCII, which is why ‘A’ is still 65.

Escape Sequences — and Why the Backslash Matters

Some characters cannot be typed straight into a String. You cannot press the Tab key inside quotation marks and expect it to survive, and you cannot type a double quote inside a double-quoted String because the compiler would think the String had ended. So Java offers escape sequences: a backslash followed by a letter or symbol, which the compiler reads as a single special character.

The one that catches people is \\. To print one backslash you must write two, because a lone backslash means something special is coming next. Counting backslashes carefully is the whole of that question.

↑ Back to top

Tokens — the Five Kinds of Word in a Java Program

Read an English sentence and your brain splits it into words and punctuation without effort. A compiler does the same thing to your program, and the smallest individual unit it recognises is called a token. There are five kinds, and the syllabus names all five.

• Keywords — words reserved by the language with a fixed meaning, which you may not use as names. Examples: class, int, void, if, new, static.
• Identifiers — the names you invent for classes, variables and methods, such as Student, marks, display.
• Literals — fixed values written directly into the code, such as 25, 3.14, 'A', "Java", true.
• Operators — symbols that perform operations, such as +, -, *, /, %, =, >.
• Punctuators — also called separators: ; , . ( ) { } [ ].

Literals, Constants and Variables

A literal is a fixed value written directly in the program — 25, 3.14, 'A', "ICSE", true. A variable is a named memory location whose value can change while the program runs. A constant is a named memory location whose value cannot be changed once assigned; in Java you make one with the final keyword, as in final double PI = 3.14;.

Two small pieces of syntax that appear in output questions. A whole number literal is int by default, so a value too large for an int needs an L suffix: long big = 9000000000L;. A decimal literal is double by default, so a float needs an f suffix: float f = 3.14f;. Forget those letters and the compiler refuses, which is itself a nice way to remember them.

The Eight Primitive Types, With Sizes and Ranges

Java has exactly eight primitive data types. Learn them as four groups and the list stops feeling arbitrary: four for whole numbers, two for decimals, one for characters, one for true or false.

Three things students get wrong here every year. char is 2 bytes in Java, not 1 — it is 1 byte in C and C++, and that is where the confusion comes from. Java uses Unicode, which needs 16 bits. Second, boolean holds only true or false, never 0 or 1; writing boolean b = 1; is a compile error. Third, the default type of a decimal literal is double, not float.

A memory trick for the four integer sizes: 1, 2, 4, 8 bytes for byte, short, int, long. They double each time, in the order the names get longer. Once you have that, float 4 and double 8 follow the same doubling.

Default values — a high-yield detail. A member variable of a class that you never initialise does not contain rubbish; Java gives it a defined default. A local variable inside a method gets no such favour, and using one before assigning it is a compile error. Knowing both halves of that sentence answers a lot of one-mark questions.

All of the above were printed by an executed program, including the char, which showed a blank with the code 0, and the String, which printed the word null.

Primitive vs Non-Primitive (Composite) Types

The eight above are primitive: built into the language, holding a single value, of a fixed size. Everything else is non-primitive, also called composite or reference type — String, arrays, and every class you or anyone else writes.

That last row is a genuinely useful test in an exam. If the type name starts with a capital letter, it is a class, therefore non-primitive. String begins with a capital S for exactly this reason — it is a class, not a primitive type, and that is a favourite one-mark trap.

One practical reason to know your types cold: almost every board program reads input from the user through the Scanner class, and Scanner has a different method for each type. Choose the wrong one and the program will not compile.

Note that there is no nextChar() — a character is read by taking a word and picking out its first letter. And remember the import line import java.util.*; at the top, without which none of this compiles.

↑ Back to top

Type Conversion — Implicit Widening and Explicit Casting

Picture two glasses, a small one and a large one. Pouring the small glass into the large one is safe — nothing spills, and you need nobody’s permission. Pouring the large glass into the small one risks losing liquid, so somebody has to take responsibility for it.

Implicit conversion, also called widening or coercion, is the safe direction. Java performs it automatically when a smaller type is assigned to a larger one, because no information can be lost. The order of widening is:

Explicit conversion, also called narrowing or type casting, is the risky direction. You must write the target type in brackets before the value, which is your way of telling the compiler that you know data may be lost and you accept it: int q = (int) 9.87; stores 9. Notice that casting a double to an int truncates — it chops the decimal part off, it does not round. (int) 9.87 is 9, not 10. If you want rounding you must ask for it with Math.round().

↑ Back to top

Four Worked Programs With Verified Output

class PrimitiveSizes
{
    public static void main(String args[])
    {
        byte   b = 100;
        short  s = 20000;
        int    i = 1000000;
        long   l = 9000000000L;
        float  f = 3.14f;
        double d = 3.14159265358979;
        char   c = 'A';
        boolean flag = true;

        System.out.println("byte    b = " + b);
        System.out.println("short   s = " + s);
        System.out.println("int     i = " + i);
        System.out.println("long    l = " + l);
        System.out.println("float   f = " + f);
        System.out.println("double  d = " + d);
        System.out.println("char    c = " + c);
        System.out.println("boolean flag = " + flag);
    }
}

byte    b = 100
short   s = 20000
int     i = 1000000
long    l = 9000000000
float   f = 3.14
double  d = 3.14159265358979
char    c = A
boolean flag = true

class EscapeDemo
{
    public static void main(String args[])
    {
        System.out.println("Name\tClass\tSection");
        System.out.println("Aarav\tX\tB");
        System.out.println("Line one\nLine two");
        System.out.println("She said, \"Java is easy\"");
        System.out.println("Path : C:\\ICSE\\Java");
        System.out.println("It\'s done");
    }
}

Name	Class	Section
Aarav	X	B
Line one
Line two
She said, "Java is easy"
Path : C:\ICSE\Java
It's done

class TypeConversion
{
    public static void main(String args[])
    {
        // implicit (widening)  -  Java does it on its own
        int    a = 7;
        double b = a;
        System.out.println("Implicit : int 7 becomes double " + b);

        char ch = 'A';
        int  code = ch;
        System.out.println("Implicit : char 'A' becomes int " + code);

        // explicit (narrowing)  -  the programmer forces it with a cast
        double p = 9.87;
        int    q = (int) p;
        System.out.println("Explicit : double 9.87 becomes int " + q);

        int    n = 66;
        char   m = (char) n;
        System.out.println("Explicit : int 66 becomes char " + m);

        // a classic trap
        System.out.println("5 / 2       = " + (5 / 2));
        System.out.println("(double)5/2 = " + ((double) 5 / 2));
    }
}

Implicit : int 7 becomes double 7.0
Implicit : char 'A' becomes int 65
Explicit : double 9.87 becomes int 9
Explicit : int 66 becomes char B
5 / 2       = 2
(double)5/2 = 2.5

class CharAscii
{
    public static void main(String args[])
    {
        char upper = 'A';
        char lower = 'a';
        char digit = '0';
        char space = ' ';

        System.out.println("'A' -> " + (int) upper);
        System.out.println("'a' -> " + (int) lower);
        System.out.println("'0' -> " + (int) digit);
        System.out.println("' ' -> " + (int) space);

        System.out.println("'A' + 1 gives " + (upper + 1));
        System.out.println("(char)('A' + 1) gives " + (char) (upper + 1));
        System.out.println("Difference 'a' - 'A' = " + (lower - upper));
    }
}

'A' -> 65
'a' -> 97
'0' -> 48
' ' -> 32
'A' + 1 gives 66
(char)('A' + 1) gives B
Difference 'a' - 'A' = 32

char up = 'G';
System.out.println((char)(up + 32));    // upper to lower

char low = 'm';
System.out.println((char)(low - 32));   // lower to upper

g
M

↑ Back to top

Output Prediction — Where the Traps Are Hidden

Cover the outputs, predict each one on paper, then check. All three fragments below were compiled and run.

System.out.println('A' + 'B');
System.out.println("A" + "B");
System.out.println((char)('A' + 2));
System.out.println(10 + 20 + "30" + 10 + 20);

131
AB
C
30301020

int    a = 7;
double b = 7.0;
System.out.println(a / 2);
System.out.println(b / 2);
System.out.println((int) 7.9 + (int) 0.9);
System.out.println((char) 97);
System.out.println(Math.round(7.5) + " " + Math.round(-7.5));

3
3.5
7
a
8 -7

byte b = 10;
short s = 20;
int r = b + s;
System.out.println("r = " + r);

float f = 5;
System.out.println("f = " + f);

long big = 100L;
int small = (int) big;
System.out.println("small = " + small);

System.out.println(5 > 3);
System.out.println((5 > 3) + " and " + (5 == 3));

r = 30
f = 5.0
small = 100
true
true and false

↑ Back to top

Practice Worksheet — 10 Questions With Model Answers

Write your answer on paper first, then reveal. Every output below was produced by an executed program, so if your prediction differs, the reason is worth finding.

Roll	Name
1	Aarav
2	Diya
Marks : "90"

161
PQ
Q

4
1
4.5
4.0

101
102
E

class Average
{
    public static void main(String args[])
    {
        int a = 70, b = 85, c = 92;
        int sum = a + b + c;
        double avg = (double) sum / 3;

        System.out.println("Sum     = " + sum);
        System.out.println("Average = " + avg);
        System.out.println("Wrong way (int division) = " + (sum / 3));
    }
}

Sum     = 247
Average = 82.33333333333333
Wrong way (int division) = 82

Before You Close This Page

You started this page thinking 5 / 2 ought to be 2.5. You now know why it is 2, and more importantly you know how to make it 2.5 when you need it. You can list eight primitive types with their sizes, explain why a char takes two bytes in Java, count backslashes without flinching, and read an expression left to right the way the compiler reads it.

If one thing is still shaky, it is almost certainly the promotion rule. Go back to the Key Idea box at the top and reread that single sentence, then redo Trap 1 and Trap 2 with a pen. Do not reread the whole page.

↑ Back to top