1.2 Data Types and Literals

Learning Objectives

•List Java's eight primitive types and their approximate storage sizes.
•Distinguish primitive types from reference types.
•Write correctly-suffixed literals for long, float, and other types.

Introduction

Java is statically typed: every value has a type known at compile time. Types split into two families — the eight built-in primitive types (holding raw numeric, character, or boolean values directly) and reference types (objects, arrays, and strings, which hold a reference to data stored elsewhere). A literal is the fixed value you write directly in source code, like `42`, `3.14`, `'A'`, or `true`.

Key Concepts

Integer types: byte (8-bit), short (16-bit), int (32-bit), long (64-bit).

Floating-point types: float (32-bit), double (64-bit, the default for decimal literals).

char (16-bit Unicode code unit) and boolean (true/false only — never 0/1 as in C).

Reference types (String, arrays, custom classes) store a reference to an object on the heap, not the object's bytes directly.

Literal suffixes: `L`/`l` for long, `F`/`f` for float, `D`/`d` for double (optional, since double is the default).

Java Syntax

Code Examples

Each variable is declared with an explicit primitive type. Underscores in numeric literals (`8_000_000`) are purely for readability and are ignored by the compiler.

Common Mistakes

⚠Assigning a whole-number literal larger than `int` range without the `L` suffix (e.g. `long big = 5000000000;` fails to compile — it needs `5000000000L`).
⚠Assuming `float` is the default for decimal literals — it's actually `double`, so `float f = 3.14;` fails without an `F` suffix or a cast.
⚠Treating `char` like a tiny integer for arithmetic without realizing it promotes to `int`.

Practice

Practice 1

True / Falseeasy

In Java, `double` is the default type for decimal literals like `3.14`.

Practice 2

Code Completionmedium

Complete the declaration so this compiles: `long total = ____;` where the value is ten billion.

Summary

Java has eight primitive types for raw values and reference types for everything else. Literals must match their target type's rules, especially the `L`/`F` suffixes for `long` and `float`.

Previous TopicNext Topic