Values and data types

A. ASCII vs Unicode Architecture:

Early programming languages (like C and C++) were built upon the ASCII (American Standard Code for Information Interchange) character set. ASCII uses 7 bits (standard, 128 characters) or 8 bits (extended, 256 characters), which is sufficient only for the Latin English alphabet, Arabic numerals, and standard punctuation.

To achieve true global universality, Java adopted the Unicode character set:

• 16-Bit Width: Unicode uses 16 bits (2 bytes) per character, providing $2^{16} = 65,536$ unique code points.
• Global Internationalization: Unicode accommodates virtually all living written languages across the globe—including Devanagari (Hindi, Sanskrit), Mandarin Chinese, Japanese Kanji, Arabic, Cyrillic, Greek, and mathematical symbols.
• Backward Compatibility: The first 128 characters of Unicode are identical to standard ASCII (e.g., 'A' is $65$, 'a' is $97$, '0' is $48$).

A. What is a Token?

A Token is the smallest individual grammatical element in a Java program recognized by the compiler. Every statement in Java is composed of tokens.

A. The 8 Primitive Data Types (Value Types):

Primitive data types are built into the core language specification and have fixed memory sizes regardless of the host machine:

B. Primitive vs Non-Primitive (Reference) Comparison:

• Primitive Types: Directly store raw binary values inside their memory allocated on the Stack. Fixed size; no methods can be called on them.
• Non-Primitive Types (Classes, Arrays, Interfaces, String): Variables store the memory address / reference to an object residing on the Heap. Default value is null. Dynamic size; possess member methods.

A. Implicit Type Conversion (Automatic Widening / Type Coercion):

Occurs automatically when the compiler converts a data type of smaller storage capacity into a data type of larger capacity. There is zero data loss.

Official Widening Hierarchy:

int a = 25;
double b = a; // Valid! Automatically widens: b becomes 25.0

B. Explicit Type Conversion (Narrowing / Type Casting):

Occurs when converting a larger data type into a smaller data type. The compiler refuses to perform this automatically because it risks data overflow or precision truncation. The programmer must use the Cast Operator: (target_type) expression.

double d = 98.75;
int i = (int) d; // Explicit cast: fractional part truncated! i becomes 98

int x = 130;
byte b = (byte) x; // Overflow! Range is -128 to 127. b wraps around to -126!

Standard Escape Sequences Table:

A. What are Wrapper Classes?

In Java, Wrapper Classes are object-oriented wrappers that encapsulate primitive data types into formal objects within the java.lang package. Each of the 8 primitive types has an exact corresponding wrapper class:

B. Autoboxing vs Unboxing:

• Autoboxing: The automatic conversion performed by the Java compiler from a primitive type directly into its corresponding wrapper object (e.g., Integer obj = 25; // Autoboxing).
• Unboxing: The automatic reverse conversion from a wrapper object back into its primitive data type (e.g., int num = obj; // Unboxing).

A. The Dual Nature of Java's `char` Data Type:

In Java, char is simultaneously a character glyph and an unsigned 16-bit integer (range: 0 to 65,535). When characters participate in arithmetic operations, their underlying ASCII/Unicode integer values are used automatically!

B. Key ASCII Integer Benchmarks:

• 'A' to 'Z' → 65 to 90
• 'a' to 'z' → 97 to 122 (Difference between uppercase and lowercase is exactly $32$)
• '0' to '9' → 48 to 57
• Space character (' ') → 32

C. High-Frequency Board Arithmetic Drills:

A. Two's Complement Representation for Signed Integers:

Java represents all signed integers (byte, short, int, long) using Two's Complement binary format:

• The most significant bit (MSB, leftmost bit) serves as the sign bit: 0 for positive, 1 for negative.
• To represent a negative number $-N$: take the binary representation of $+N$, invert all bits (1's complement), and add 1.

B. Why Byte Wraps from 127 to -128 (Overflow Mechanics):

An 8-bit byte holding 127 has binary value 01111111. Adding 1 produces 10000000. In two's complement, 10000000 represents $-128$! This circular wrapping behavior explains why assigning 130 to a byte yields -126 ($127 + 3 ightarrow -128 + 2 = -126$).

A. The IEEE 754 Standard in Java:

Java float (32-bit single precision) and double (64-bit double precision) comply strictly with the international IEEE 754 standard for floating-point arithmetic. Because numbers are represented internally as binary fractions, certain base-10 decimal fractions cannot be represented exactly in binary.

• Example: Evaluating System.out.println(0.1 + 0.2); produces 0.30000000000000004 rather than exactly 0.3!
• Special Floating-Point Constants:
  • Double.POSITIVE_INFINITY: Produced by dividing a positive float by zero (1.0 / 0.0).
  • Double.NEGATIVE_INFINITY: Produced by dividing a negative float by zero (-1.0 / 0.0).
  • Double.NaN: "Not a Number", produced by undefined mathematical operations like 0.0 / 0.0 or Math.sqrt(-4.0).