---
title: Java Variables and Data Types Explained in Plain English – Quick Start for New Coders
siteUrl: https://logzly.com/javajumpstart
author: javajumpstart (Java Jumpstart)
date: 2026-06-16T15:22:21.907710
tags: [java, programming, beginners]
url: https://logzly.com/javajumpstart/java-variables-and-data-types-explained-in-plain-english-quick-start-for-new-coders
---


When you first open a Java file, the biggest mystery is often the sea of words like `int`, `String`, and `double`. They look like secret code, but they are really just labels that tell the computer what kind of information you are storing. Getting a grip on variables and data types is the first step to [writing any Java program](/javajumpstart/write-and-run-your-first-java-program-in-10-minutes), and it will make the rest of your learning feel a lot less scary.

## What is a Variable?

Think of a variable as a labeled box that you can put something inside. The label (the variable name) lets you find the box later, and the thing you put inside can be a number, a word, or even a more complex object. In Java you have to tell the computer two things before you can use the box:

1. **What kind of thing will go in the box?** – This is the data type.
2. **What is the name of the box?** – This is the variable name.

Only after you give both pieces of information can you store a value in the box.

```java
int age;          // a box that will hold an integer number
String name;     // a box that will hold a sequence of characters
```

If you try to put a word into `age` or a number into `name`, Java will shout an error. This strictness is actually a good thing because it catches many bugs before the program even runs.

## Common Data Types

Java has a handful of built‑in data types that cover most of what beginners need. Below is a quick tour of the most useful ones.

### int – Whole Numbers

`int` stands for integer. It stores whole numbers from -2,147,483,648 to 2,147,483,647. Use it for counts, ages, or any value that never needs a fraction.

```java
int apples = 5;
```

### double – Numbers with Decimals

When you need a number that can have a fraction, `double` is the go‑to type. It can store very large or very small values, but keep in mind it is a floating‑point number, which means some decimal values are approximated.

```java
double price = 19.99;
```

### boolean – True or False

A `boolean` can only be `true` or `false`. It’s perfect for flags, switches, or any condition you need to test.

```java
boolean isStudent = true;
```

### char – A Single Character

A `char` holds exactly one Unicode character, such as a letter, digit, or symbol. It is written inside single quotes.

```java
char grade = 'A';
```

### String – Text

Even though `String` looks like a class, it behaves like a basic data type for most beginners. It stores a sequence of characters, like a word or a whole sentence. Use double quotes.

```java
String greeting = "Hello, Java!";
```

## How to Declare and Use Variables

Declaring a variable is like setting up the empty box. You can also give it a value right away, which is called **initializing**.

```java
int score = 0;          // declare and initialize
String city;            // declare only, value is not set yet
city = "Paris";         // later we assign a value
```

### Naming Rules

- Start with a letter, `$`, or `_`. Most people just start with a letter.
- After the first character you can use letters, numbers, `$`, or `_`.
- No spaces or special symbols like `@` or `#`.
- Java is case‑sensitive, so `total` and `Total` are different variables.

A good habit is to use **camelCase**: start with a lower‑case letter and capitalize the first letter of each new word.

```java
int numberOfCats = 3;
```

### Updating a Variable

You can change the value inside a box as many times as you like.

```java
int counter = 10;
counter = counter + 1;   // now counter is 11
counter++;               // shorthand for adding 1
```

### Using Variables in Expressions

Variables can be combined with operators to create new values.

```java
int length = 8;
int width  = 5;
int area = length * width;   // area is 40
```

## Tips to Avoid Common Mistakes

1. **Never use a variable before it’s initialized.**  
   Java will refuse to compile code that reads a variable that has no value yet.

2. **Match the type to the data.**  
   Trying to store a decimal number in an `int` will cause a compile error. If you need a fraction, pick `double`.

3. **Watch out for integer division.**  
   Dividing two `int` values drops the fractional part. If you need a precise result, cast one operand to `double`.

   ```java
   int a = 7;
   int b = 2;
   double result = (double) a / b;   // result is 3.5
   ```

4. **Keep variable scope in mind.**  
   A variable declared inside a method cannot be used outside that method. Think of scope as the room where the box lives.

5. **Use meaningful names.**  
   `int x` tells the reader nothing. `int daysUntilHoliday` instantly conveys purpose.

## A Quick Mini‑Project

Let’s put everything together with a tiny [Java console app](/javajumpstart/build-your-first-java-console-app-a-stepbystep-guide-for-absolute-beginners) that asks for a user’s name and age, then prints a friendly message.

```java
import java.util.Scanner;

public class Welcome {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter your name: ");
        String name = scanner.nextLine();

        System.out.print("Enter your age: ");
        int age = scanner.nextInt();

        System.out.println("Hello, " + name + "! Next year you will be " + (age + 1) + " years old.");
    }
}
```

Notice how we used `String` for the name, `int` for the age, and a simple arithmetic expression to add one. The program is short, but it shows how variables and data types work together in a real scenario.

---

Getting comfortable with variables and data types is like learning the alphabet before you start writing stories. Once you know the building blocks, you can start arranging them into loops, conditionals, and eventually full‑blown applications. Keep experimenting, and soon those mysterious words will feel like old friends.