Variables, Types, Literals, Keywords

Read a declaration from left to right

int score = 91;

A declaration introduces the variable. An initializer supplies its first value.

int attempts;       // declaration
attempts = 1;       // assignment
int score = 91;     // declaration with an initializer

The declared type does not change later:

int score = 91;
score = 95;         // valid: another int value
// score = true;    // compile-time error

This is static typing. Java checks types during compilation, before these statements run.

Identifiers and keywords

An identifier is a name chosen by the programmer. Use names that state what a value means.

double unitPrice = 12.50;
int quantity = 4;
double total = unitPrice * quantity;

Identifiers are case-sensitive. total, Total, and TOTAL are different names.

Common identifiers use letters, digits, _, and $, and cannot start with a digit. Java also accepts many Unicode letters and currency symbols. It reserves keywords such as class, int, public, and return for the language grammar.

int classSize = 30;  // valid
// int class = 30;   // invalid: class is a keyword

The eight primitive types

Java defines exactly eight primitive types.

The integer widths and ranges are fixed by the Java language. They do not change between a 32-bit laptop and a 64-bit server.

char stores a code unit

This program shows both the useful case and the boundary:

public class CharDemo {
    public static void main(String[] args) {
        char latin = 'A';
        char devanagari = '\u0915';
        String rocket = "🚀";

        System.out.println(latin);
        System.out.println(devanagari);
        System.out.println(rocket.length());
        System.out.println(rocket.codePointCount(0, rocket.length()));
    }
}

Output:

A
क
2
1

The rocket is one Unicode code point represented by two UTF-16 code units. String.length() counts code units, so it returns 2 here.

Choose a default, then justify exceptions

Use int for ordinary whole-number calculations and double for ordinary binary floating-point calculations. Choose another type when its range, precision, API contract, storage density, or domain meaning gives a concrete benefit.

float is useful in some graphics and large numeric arrays. byte is useful for encoded binary data. long is required when int cannot cover the range. Money and other exact decimal quantities need a decimal representation such as BigDecimal, not double.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Why does `byte` stop at 127 when eight bits provide 256 patterns?

   Show the answer

   byte is signed. Its 256 patterns represent -128 through 127: 128 negative values, zero, and 127 positive values. The exact interpretation is fixed-width two's complement, which Section 2.2 derives.

2. Why does `float price = 3.99;` fail even though 3.99 is inside the range of `float`?

   Show the answer

   The literal 3.99 has type double. Assigning it to float is a narrowing conversion, so Java requires an explicit cast or an f suffix. Write float price = 3.99f;, or keep the greater precision with double price = 3.99;.

3. Does `char` always hold one complete visible character?

   Show the answer

   No. A char is one unsigned 16-bit UTF-16 code unit. Many common characters use one code unit, but some Unicode characters use a surrogate pair and therefore need two char values. Text normally belongs in a String.

4. How many bytes does a Java `boolean` occupy?

   Show the answer

   The Java language does not specify a storage size for boolean. It specifies only the values true and false. Object layout, fields, arrays, and JVM implementations can represent booleans differently, so do not derive memory totals from a claimed one-bit or one-byte size.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

5 exercises105 pointsabout 110 minutes

class Primitives {
    static byte aByte()
    static short aShort()
    static int anInt()
    static long aLong()
    static float aFloat()
    static double aDouble()
    static char aChar()
    static boolean aBoolean()
}

public class Primitives {

    // One method per primitive type. Return a sensible value from each.
    // Two of them need a suffix on the literal. Two of them need particular quotes.

    static byte    aByte()    { return 0; }     // TODO
    static short   aShort()   { return 0; }     // TODO: big enough that a byte could not hold it
    static int     anInt()    { return 0; }     // TODO
    static long    aLong()    { return 0; }     // TODO: big enough that an int could not hold it
    static float   aFloat()   { return 0; }     // TODO
    static double  aDouble()  { return 0; }     // TODO
    static char    aChar()    { return 0; }     // TODO
    static boolean aBoolean() { return false; } // TODO

    public static void main(String[] args) {
        // TODO: print all eight, one per line
    }
}

byte   smallCount     = 100
short  mediumCount    = 30000
int    population     = 1400000000
long   distanceInKm   = 9460730472580800
float  roughPrice     = 3.99
double preciseValue   = 3.14159265358979
char   grade          = A
boolean isActive      = true

class Overflow {
    static int intOverflow()
    static byte byteOverflow()
    static short shortOverflow()
    static long longOverflow()
    static boolean threwAnything()
}

public class Overflow {

    // Add one to each type's maximum and return what you get.
    // PREDICT all four before running.

    static int   intOverflow()   { return 0; }  // TODO
    static byte  byteOverflow()  { return 0; }  // TODO: this one needs a cast. Work out why
    static short shortOverflow() { return 0; }  // TODO
    static long  longOverflow()  { return 0; }  // TODO

    // Did anything get thrown? Try it and find out.
    static boolean threwAnything() {
        return true; // TODO
    }

    public static void main(String[] args) {
        // TODO: print all four, plus whether anything was thrown
    }
}

class Broken {
    static long distance()
    static float price()
    static char grade()
    static int classSize()
    static byte count()
    static boolean ready()
}

public class Broken {

    // Six declarations, six different rules broken. Fix each one.
    // Read the compiler error first, and name the rule before you change anything.

    static long    distance()  { return 9460730472580800; }  // TODO
    static float   price()     { return 3.99; }              // TODO
    static char    grade()     { return "A"; }               // TODO
    static int     classSize() { return class; }             // TODO
    static byte    count()     { return 200; }               // TODO
    static boolean ready()     { return 1; }                 // TODO

    public static void main(String[] args) {
        // TODO: print all six once they compile
    }
}

class Registry {
    static String unitName()
    static int unitId()
    static double readiness()
    static boolean active()
    static char classification()
    static long serialNumber()
    static byte crewSize()
}

public class Registry {

    // One unit in the registry. Choose each type deliberately and be ready to defend it.
    // The serial number is past 2,147,483,647. The readiness has a fraction.

    static String  unitName()       { return ""; }    // TODO
    static int     unitId()         { return 0; }     // TODO
    static double  readiness()      { return 0; }     // TODO
    static boolean active()         { return false; } // TODO
    static char    classification() { return 0; }     // TODO
    static long    serialNumber()   { return 0; }     // TODO
    static byte    crewSize()       { return 0; }     // TODO

    public static void main(String[] args) {
        // TODO: print a tidy record of this unit
    }
}

class Ranges {
    static long minOf(int bits)
    static long maxOf(int bits)
    static long unsignedMaxOf(int bits)
    static long countOf(int bits)
}

public class Ranges {

    // Derive these from the bit count. Do NOT return remembered constants:
    // the checks call these with 4 bits and 12 bits as well.

    // Signed, so one bit is the sign.
    static long minOf(int bits) { return 0; }  // TODO
    static long maxOf(int bits) { return 0; }  // TODO

    // An unsigned n-bit pattern. Java's char is the only unsigned integral
    // primitive, and it represents one UTF-16 code unit.
    static long unsignedMaxOf(int bits) { return 0; }  // TODO

    // How many values fit. The long return type limits this method to 1..62 bits:
    // 2^63 and 2^64 are positive counts that do not fit in a signed long.
    static long countOf(int bits) { return 0; }  // TODO

    public static void main(String[] args) {
        // TODO: print signed ranges for 8, 16, 32 and 64 bits
        // TODO: print counts only where the positive result fits in long
    }
}