Data Types

Data Types

In Java, data types define the type of data that a variable can hold. They also determine the amount of memory allocated to the variable and the range of values it can store.

1. Categories of Data Types

Java data types are broadly classified into two categories:

1. Primitive Data Types

2. Non-Primitive (Reference) Data Types

This section focuses on primitive data types.

2. Primitive Data Types

Java has eight primitive data types, which are divided into four groups based on the kind of values they store:

A. Integral Types

Used to store whole numbers (integers).

• byte

• short

• int

• long

B. Floating-Point Types

Used to store numbers with decimal points.

• float

• double

C. Character Type

Used to store a single Unicode character.

• char

D. Boolean Type

Used to store logical values.

• boolean

3. Primitive Data Type Details

What are Variables ?

A variable is a name given to a memory location that stores a value. In Java, variables are used to store data that can be used and modified during program execution.

Each variable has:

1. A data type — which defines the kind of value it can store (e.g., integer, float, character, etc.)

2. A name — which identifies the variable in the program

3. A value — which represents the actual data stored

The general syntax for declaring a variable is:

dataType variableName = value;

int i = 175; ⬜ ⬜ ⬜ ⬜

float f = 25.3f; ⬜ ⬜ ⬜ ⬜

char c = ‘A’; ⬜ ⬜

byte b = 5; ⬜

Rules for Variable Names

In Java, variable names (also called identifiers) must follow specific rules to ensure that the code is valid and readable. The following are the key rules and best practices for naming variables:

1. Case Sensitivity

Variable names in Java are case-sensitive.
This means age, Age, and AGE are considered three different variables.

2. Allowed Characters

A variable name can contain:

• Alphabets (A–Z, a–z)

• Digits (0–9)

• The underscore (_)

• The dollar sign ($)

3. Starting Character

A variable name must start with:

• A letter (A–Z or a–z)

• An underscore (_)

• Or a dollar sign ($)

It cannot start with a digit.

4. Not a Keyword

A variable name cannot be a Java keyword (like class, int, if, return, etc.).

5. Avoid Class Names in Use

If a class with a certain name already exists, avoid using that same name for a variable to prevent confusion and ambiguity.

6. No Length Limit

There is no limit to the length of a variable name.
However, names should be kept meaningful and concise for readability.

7. Use Camel Case Convention

Java developers commonly follow the camelCase naming convention for variables:

• The first word starts with a lowercase letter.

• Each subsequent word begins with an uppercase letter.

What are Literals

A literal is a constant value that is directly written in the code. It represents a fixed value that does not change during program execution. In Java, literals are used to assign values to variables of various data types.

1. Integer Literals

Integer literals represent whole numbers (without a fractional part). For example:

z = 2 x + 17 y;

Here, 2 and 17 are integer literals.
Variables of type byte, short, and int can be initialized using integer literals (of type int), as long as the value fits within the range of the target type.

A long variable is initialized using a long literal by appending L or l at the end of the number:

long distance = 4124L;

2. Floating-Point Literals

Floating-point literals represent real numbers that contain a decimal point.
A float literal is written with an f or F suffix:

float rate = 2.34f;

A double literal can be written either with or without a d or D suffix:

double price = 456.41;

double tax = 2.34D;

3. Character Literals

A character literal represents a single character enclosed within single quotes:

char c = 'A';

4. String Literals

A string literal represents a sequence of characters enclosed within double quotes:

String s = "Java";

5. Boolean Literals

A boolean literal has only two possible values: true or false.

boolean isActive = true;

boolean isComplete = false;

6. Number System Literals

Java supports several types of number system literals:

• Binary literals (prefix 0b or 0B):
  int binaryNum = 0b1010; // equivalent to 10 in decimal

• Octal literals (prefix 0):
  int octalNum = 012; // equivalent to 10 in decimal

• Hexadecimal literals (prefix 0x or 0X):
  int hexNum = 0xA; // equivalent to 10 in decimal

Integral Data Type

When Java was first introduced, 32-bit systems were the standard in computing. Because of this, Java designed the int data type to occupy 4 bytes (32 bits).
If integers had been stored in only 2 bytes (16 bits), it would have underutilized the processor’s capabilities, leading to slower performance.
Hence, int in Java is always 32 bits, regardless of the underlying machine architecture, ensuring platform independence.

Understanding How Integers Are Stored

To understand how integral data types (like byte, short, int, long) store numbers, we need to look at binary representation.

Let’s take the example of the byte data type.

• A byte is 1 byte = 8 bits.

• It can store values from –128 to 127.

• The most significant bit (MSB) — the 7th bit (counting from 0 to 7, right to left) — is used as the sign bit.

  • 0 → positive number

  • 1 → negative number

Example: Representing 127
01111111

• The first bit (0) indicates it’s positive.

• The remaining 7 bits represent the value 1111111, which equals 127 in decimal.

Example: Representing -5

To store a negative number like -5, Java (and most programming languages) uses a system called Two’s Complement representation.

Here’s how it works step by step:

1. Find the binary of 5:
   00000101

2. Find the One’s Complement:
   (Invert all bits: 0 → 1 and 1 → 0)
   11111010

3. Find the Two’s Complement:
   (Add 1 to the One’s Complement)
   11111010 + 1 = 11111011

4. Result:
   11111011 → represents -5

Float Data Type

In Java, floating-point data types are used to represent numbers that have a fractional part — that is, numbers with decimal points. Examples include 3.14, 0.001, or -98.6.

Java provides two floating-point types:

• float (4 bytes, single precision)

• double (8 bytes, double precision)

Both types follow the IEEE 754 standard for representing floating-point numbers in binary form.

Understanding Floating-Point Representation

A floating-point number is represented internally using scientific notation.
In this format, a number is expressed as:

Number = Mantissa × 10^(Exponent)

• The mantissa (or significand) represents the actual digits of the number.

• The exponent represents the power of 10 (or 2 in binary form) that determines where the decimal point is placed.

This allows very large or very small numbers to be stored efficiently.

Example: Representing 163.52

Let’s understand how 163.52 can be expressed in floating-point form.

163.52 = 16352 / 100 = 16352 × 10^−2

• Mantissa: 16352

• Exponent: -2

This can be written as: 16352E-2

In Java notation, the letter E (or e) is used to represent “×10 to the power of”.
So, 16352E-2 means: 163.52

How Float Is Stored Internally

A float in Java is a 32-bit (4-byte) value and is divided into three parts as per the IEEE 754 single-precision format:

So, a 32-bit float looks like this: [ Sign (1 bit) ][ Exponent (8 bits) ][ Mantissa (23 bits) ]

For a deeper look at how these bits actually represent floating-point numbers in memory (with binary breakdowns and examples), check out this detailed explanation:

👉 Understanding IEEE 754 Floating-Point Representation (external link)

👉 How float or double values are stored in memory? (external link)