Java Variables and Primitive Data Types

Variables are the most basic way to store data in a Java program. Think of a variable as a named box in your computer's memory. You choose the box (declare it), give it a name, and then put something inside (initialise it). Once you have the box, you can read its contents, change them, or use them in calculations.

Primitive data types are the simplest kinds of data Java understands directly. They are not objects — they are raw data. Java has eight primitive types, but for the 1Z0-811 exam, you only need to focus on four: int, double, boolean, and char.

int stands for integer. It holds whole numbers — numbers without a decimal point — between -2,147,483,648 and 2,147,483,647. When you declare an int variable, you are reserving 32 bits of memory to store a whole number. For example: int age = 30; Here 'int' is the type, 'age' is the variable name, and '30' is the value.

double holds decimal numbers. It is a floating-point type, meaning it can handle numbers with fractional parts. It uses 64 bits of memory and can store much larger and smaller values than int. For example: double price = 19.99; If you need to store a measurement or a monetary value, double is what you use.

boolean is the simplest type — it holds only two possible values: true or false. It is like a light switch that is either on or off. Booleans are essential for making decisions in code. For example: boolean isReady = true;

char holds a single character — a letter, digit, punctuation mark, or symbol. It uses 16 bits and stores a Unicode character, which means it can represent characters from many different languages. You write char values inside single quotes, like this: char grade = 'A'; Note the single quotes — double quotes are used for strings, which are not primitive.

Declaring a variable means telling Java what type it is and what its name will be. The syntax is: type name; For example: int count; This creates a box named 'count' that can hold integers, but it is empty until you put a value in it.

Initialising a variable means assigning it a value for the first time. You can do it on the same line as the declaration: int count = 10; Or you can declare first, then assign later: int count; count = 10; Both are valid.

You can also declare multiple variables of the same type in one line: int a, b, c; But this is only for the same type. You cannot mix types in one declaration.

One common rule: local variables (variables declared inside a method) MUST be initialised before you use them. If you try to use a variable that has been declared but not given a value, Java will give you a compile error saying the variable might not have been initialised. This is a favourite trick on the exam.

Here are the key rules for naming variables:

Why do we need different types? Because different kinds of data use different amounts of memory and behave differently. You wouldn't use a bucket to store a teaspoon of salt, and you wouldn't use a thimble to store a gallon of water. Similarly, using int for a decimal number would lose the decimal part, and using double for a whole number wastes memory. Java is strict about types to prevent these kinds of mistakes.

When you assign a value that is too large for an int, Java gives a compile error. When you assign a decimal number to an int, Java also gives a compile error unless you explicitly convert it, which can lose data. This type safety is one of Java's strengths — it catches bugs before your program even runs.

Imagine you are writing software for a small online bookstore. Your first task is to create a program that stores information about each book. In the real world, an IT professional would use variables to hold all the necessary details.

First, you need to store the price of a book. Prices have decimals, so you would use a double variable. You might declare: double price = 12.99; But if the book is on sale and the price drops to 9.99, you can later change the value: price = 9.99; This is what real developers do constantly — updating variable values as data changes.

Next, you need to track how many copies of the book are in stock. Since you cannot have half a book, you would use an int: int quantityInStock = 50; When a customer buys a book, the developer would decrease this number: quantityInStock = quantityInStock - 1; This kind of arithmetic with int variables is extremely common.

You also need to know whether the book is currently available for purchase. This is a perfect use for a boolean: boolean isAvailable = true; If the stock runs out, the developer sets isAvailable = false; Then the website can hide the 'Add to Cart' button based on that variable.

Finally, you might want to display a single character rating for the book, like 'A', 'B', or 'C'. This would be a char: char rating = 'A';

Step by step, what does a developer do? - They identify what data the program needs to handle. - They choose the correct primitive type for each piece of data. - They declare the variables with clear, descriptive names. - They initialise the variables with starting values (often from a database or user input). - They use the variables in calculations, comparisons, and output statements. - They update the variables as the program runs.

In a real project, developers also have to consider scope — where a variable is accessible. A variable declared inside a method can only be used inside that method. But for the 1Z0-811 exam, you mostly work with local variables inside methods.

Another real-world scenario: building a simple calculator app. You would need int or double variables for the two numbers the user enters. You would need a char variable to store the operator (+, -, *, /). You would need a boolean variable to check if the calculation is valid. Then you would use these variables in if-statements and arithmetic expressions.

The key point is that every professional Java program, no matter how complex, is built on these same primitive types. They are the foundation. Without mastering variables and data types, you cannot write any meaningful code.