📘 Full Explanation: Data Types in Java — Deep Dive with Real Insight

🧠 What Are Data Types?

In Java, data types define what kind of data a variable can hold. This is crucial because Java is a statically-typed language — the compiler needs to know the type of every variable before it runs.

Java's Type System

• Java is a typed language. That means every variable must be declared with a type.
• Example: int age = 25; — int tells Java that age stores integers.
• This is different from dynamically typed languages like JavaScript, where you can write:

let age = 25;  // No type specified

Java enforces type safety, which reduces runtime errors.

🔢 Java Data Types — The Two Categories

1. Primitive Data Types (Built-in)

These are predefined by Java, lightweight, and fast. Java has 8 primitive data types:

➡️ Important: All primitive data types start with lowercase letters in Java.

2. Non-Primitive Data Types (Reference types)

These are objects, created by the programmer or Java itself. Examples:

• String (a sequence of characters)
• Arrays, Classes, Interfaces

We’ll focus on primitive types first, as in the lecture.

🧬 Deep Dive into Each Primitive Data Type

1. byte

Size: 8 bits (1 byte)
Range: -128 to 127 (256 total values)
Use Case: For memory-efficient storage in large arrays.

byte myByte = 8;
System.out.println(myByte); // prints 8

2. short

Size: 2 bytes (16 bits)
Range: -32,768 to 32,767
Less common in real-world Java — int is preferred.

3. int

Size: 4 bytes
Range: ~ -2 billion to +2 billion
Most used data type for whole numbers

int age = 25;
System.out.println(age);

4. long

Size: 8 bytes
Range: Way bigger than int
Use Case: Timestamps, large IDs

long population = 8000000000L;

5. float

Size: 4 bytes
Precision: Up to 7 decimal places
Decimal numbers (use f suffix)

float pencilPrice = 10.5f;

6. double

Size: 8 bytes
Precision: Up to 15 decimal places
Default for decimal values

double pi = 3.14159265359;

7. char

Size: 2 bytes
Stores: Single character
Use single quotes 'A', not double quotes

char grade = 'A';

8. boolean

Size: 1 bit
Values: true or false
Use Case: Conditional logic

boolean isJavaFun = true;

🧮 Understanding Memory and Range

Java allocates memory based on data type.
A byte = 8 bits → Can store 2⁸ = 256 values

This explains:

• Why byte stores only -128 to 127
• Why int can store billions

Formula:
Range = −(2ⁿ⁻¹) to (2ⁿ⁻¹ − 1), where n is the number of bits

🧑‍💻 Real-World Examples

📓 Detailed Study Notes (Formatted for Reading)

🧱 Java Primitive Data Types

➤ Integer Types:

• byte — 1 byte, small numbers
• short — 2 bytes
• int — 4 bytes, default for whole numbers
• long — 8 bytes, large integers

➤ Floating-Point Types:

• float — 4 bytes, less precise
• double — 8 bytes, more precise, default

➤ Others:

• char — single Unicode character (like 'A', '%')
• boolean — true / false

🧾 Condensed Revision Notes

• Java is statically typed: must declare variable types.
• 8 primitive types in Java:
  • byte, short, int, long (integers)
  • float, double (decimals)
  • char (single character)
  • boolean (true/false)
• Use float with f, long with L
• Memory: 1 byte = 8 bits → defines range
• Use int and double by default unless memory or precision is an issue
• Use boolean in conditions: if (isActive) {...}

🧠 Easy-to-Forget Points — and Memory Tricks

🎯 Interview Questions and Full Answers

✅ Q1: Why is Java called a statically typed language?

Java is statically typed because every variable must be declared with a data type at compile time. This allows the Java compiler to:

• Check for type mismatches
• Prevent runtime errors
• Allocate efficient memory

int age = 25; // age must hold an int
age = "twenty"; // Error! Can't assign String to int

✅ Q2: What are the 8 primitive data types in Java and their sizes?

✅ Q3: What is the difference between float and double?

• float uses 4 bytes, double uses 8 bytes
• float is less precise (up to 7 digits), double is more precise (up to 15 digits)
• Use float only when memory is tight (e.g., on mobile devices)

float price = 10.5f;
double pi = 3.14159265359;

✅ Q4: What happens if you assign a value outside the range of a data type?

It causes a compilation error or unexpected behavior.

byte b = 130; // Error: 130 is outside byte range (-128 to 127)

Java won't allow overflow silently (unlike C in some cases).

✅ Q5: Why do we have multiple integer types in Java (byte, short, int, long)?

• Each type is optimized for:
  • Memory efficiency: byte and short are useful in large arrays or embedded systems
  • Performance: smaller data types can be faster
  • Precision: long is used when int isn’t big enough
• Using just one type (like only int) would:
  • Waste memory
  • Limit program scalability