Java Data Types

Java Data Types

As explained in the previous chapter, a variable in Java must be a specified data type. Data types are divided into two groups:

1. Primitive data types: Includes byte, short, int, long, float, double, boolean and char.
2. Non-primitive data types (Reference Types): Includes String, Arrays, and Classes.

💡 Analogy time: Imagine you have different types of containers for different items in your kitchen.

• You use a small shaker for a little bit of salt (byte or short).
• You use a large jug for holding a lot of water (int or long).
• You use a measuring cup for liquids that require precise fractional measurements (float or double). Choosing the right data type ensures you don't waste memory (using a massive jug for a pinch of salt) and prevents errors (overflowing the small shaker with too much water).

1. Primitive Data Types

A primitive data type specifies the size and type of variable values, and it has no additional methods. They are the most basic data types available in Java.

Integer Types

Integer types store whole numbers, positive or negative, without decimals.

• byte: Stores whole numbers from -128 to 127. Saves memory. (1 byte)
• short: Stores whole numbers from -32,768 to 32,767. (2 bytes)
• int: The most commonly used integer type. Stores whole numbers from -2,147,483,648 to 2,147,483,647. (4 bytes)
• long: Used when int is not large enough. Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. The value should end with an 'L'. (8 bytes)

byte myByte = 100;
short myShort = 5000;
int myInt = 100000;
long myLong = 15000000000L;
System.out.println(myLong);

Floating-Point Types

Floating-point types represent numbers with a fractional part.

• float: Stores fractional numbers. Sufficient for 6 to 7 decimal digits. The value should end with an 'f'. (4 bytes)
• double: The most commonly used float type. Sufficient for about 15 decimal digits. The value can end with a 'd' (optional). (8 bytes)

float myFloat = 5.75f;
double myDouble = 19.99d;
System.out.println(myFloat);

Other Primitive Types

• boolean: Can only have one of two values: true or false. It is often used for conditional testing. (1 bit)
• char: Used to store a single character. The character must be surrounded by single quotes, like 'A' or 'c'. (2 bytes)

boolean isJavaFun = true;
char myGrade = 'B';
System.out.println("Is Java fun? " + isJavaFun);
System.out.println("My grade is: " + myGrade);

2. Non-Primitive (Reference) Data Types

Non-primitive data types are called reference types because they refer to objects.

The main difference between primitive and non-primitive data types are:

• Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer (except for String).
• Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.
• A primitive type always has a value, while non-primitive types can be null.
• A primitive type starts with a lowercase letter, while non-primitive types start with an uppercase letter.

Examples of non-primitive types include Strings, Arrays, Classes, Interfaces, etc.

public class Main {
  public static void main(String[] args) {
    // The 'greeting' variable holds a reference to a String object
    String greeting = "Hello World";
    // We can call methods on the object
    System.out.println("The length of the string is: " + greeting.length());
  }
}

Deep Dive: Stack vs. Heap Memory (Why "Reference" Types?)

To truly master Java, it helps to understand how it stores these two different groups of data in your computer's memory. Java uses two main areas of memory: the Stack and the Heap.

• The Stack (Fast & Small): This is where Java stores Primitive data types. Because primitives have a strict, known size (like exactly 4 bytes for an int), Java stacks them up efficiently.
• The Heap (Slower & Massive): This is where Java stores Non-Primitive (Objects). A String or an Array can be huge and change size, so they need a massive open space.

📺 The "TV Remote" Analogy: When you create a non-primitive variable like String myText = "Hello";, Java doesn't actually squeeze the word "Hello" into the myText variable. Instead, it builds the massive "Hello" object out on the Heap. Then, it gives your myText variable a Reference (which is essentially a memory address, like a TV remote) and stores that tiny remote on the Stack. When you use myText, you are "clicking the remote" to talk to the giant object out on the Heap!

Advanced Notes: Data Types

• Primitive types store raw values; reference types store references to objects. This affects memory, comparison, and null handling.
• Use int for most whole numbers and long when values may exceed the int range.
• Use BigDecimal for precise decimal calculations such as money; float and double can have rounding errors.
• Wrapper classes like Integer and Double are needed for collections and generics. Java converts with boxing and unboxing.
• char stores a UTF-16 code unit, not always a full user-visible character. Some symbols require multiple code units.