title: Java Variables and Literals

description: Variables and Literals in Java

import { Heading } from '@/components/Heading'

import Link from 'next/link'

import { TipInfo } from '@/components/Tip'

In this tutorial, we will learn about Java variables and literals with the help of examples.

A variable is a location in memory (storage area) to hold data.

To indicate the storage area, each variable should be given a unique name (identifier). Learn more about [Java identifiers](https://javaistic.vercel.app/java-introduction/keywords-identifiers).

Here's how we create a variable in Java,

int speedLimit = 80;

Here, `speedLimit` is a variable of `int` data type and we have assigned value **80** to it.

The int data type suggests that the variable can only hold integers.

To learn more, visit [Java data types](/docs/variables-primitive-data-types).

In the example, we have assigned value to the variable during declaration. However, it's not mandatory.

You can declare variables and assign variables separately. For example,

int speedLimit;

speedLimit = 80;

<p className="mt-4"/>

<TipInfo>

**Note :** Java is a statically-typed language. It means that all variables

must be declared before they can be used.

</TipInfo>

The value of a variable can be changed in the program, hence the name variable. For example,

int speedLimit = 80;

... .. ...

speedLimit = 90;

Here, initially, the value of `speedLimit` is **80**. Later, we changed it to **90**.

However, we cannot change the data type of a variable in Java within the same scope.

What is the variable scope?

Don't worry about it for now. Just remember that we can't do something like this:

int speedLimit = 80;

... .. ...

float speedLimit;

To learn more, visit: [Can I change declaration type for a variable in Java](http://stackoverflow.com/questions/27092245/can-i-change-declaration-type-for-a-variable-in-java)?

Java programming language has its own set of rules and conventions for naming variables. Here's what you need to know:

- Java is case sensitive. Hence, `age` and `AGE` are two different variables. For example,

int age = 24;

int AGE = 25;

System.out.println(age); // prints 24

System.out.println(AGE); // prints 25

- Variables must start with either a **letter** or an **underscore**, **\_** or a **dollar**, **$** sign. For example,

int age; // valid name and good practice

int _age; // valid but bad practice

int $age; // valid but bad practice

- Variable names cannot start with numbers. For example,

int 1age; // invalid variables

- Variable names can't use whitespace. For example,

int my age; // invalid variables

Here, is we need to use variable names having more than one word, use all lowercase letters for the first word and capitalize the first letter of each subsequent word. For example, `myAge`.

- When creating variables, choose a name that makes sense. For example, `score` , `number` , `level` makes more sense than variable names such as `s` ,`n` , and `l`.

- If you choose one-word variable names, use all lowercase letters. For example, it's better to use `speed` rather than `SPEED`, or `sPEED`.

There are 4 types of variables in Java programming language:

- **Instance Variables (Non-Static Fields)**

- **Class Variables (Static Fields)**

- **Local Variables**

- **Parameters**

If you are interested to learn more about it now, visit [Java Variable Types](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html).

Literals are data used for representing fixed values. They can be used directly in the code. For example,

int a = 1;

float b = 2.5;

char c = 'F';

Here, `1` , `2.5` , and `'F'` are literals.

Here are different types of literals in Java.

In Java, boolean literals are used to initialize boolean data types. They can store two values: true and false. For example,

boolean flag1 = false;

boolean flag2 = true;

Here, `false` and `true` are two boolean literals.

An integer literal is a numeric value(associated with numbers) without any fractional or exponential part. There are 4 types of integer literals in Java:

1. binary (base 2)

2. decimal (base 10)

3. octal (base 8)

4. hexadecimal (base 16)

For example:

int binaryNumber = 0b10010;

int octalNumber = 027;

int decNumber = 34;

int hexNumber = 0x2F; // 0x represents hexadecimal

int binNumber = 0b10010; // 0b represents binary

In Java, binary starts with **0b**, octal starts with **0**, and hexadecimal starts with **0x**.

<p className="mt-4"/>

<TipInfo>

**Note :** Integer literals are used to initialize variables of integer types

like `byte` , `short` , `int` , and `long` .

</TipInfo>

A floating-point literal is a numeric literal that has either a fractional form or an exponential form. For example,

class Main {

public static void main(String[] args) {

double myDouble = 3.4;

float myFloat = 3.4F;

// 3.445*10^2

double myDoubleScientific = 3.445e2;

System.out.println(myDouble); // prints 3.4

System.out.println(myFloat); // prints 3.4

System.out.println(myDoubleScientific); // prints 344.5

}

}

<p className="mt-4"/>

<TipInfo>

**Note :** The floating-point literals are used to initialize `float` and `double`

type variables.

</TipInfo>

Character literals are unicode character enclosed inside single quotes. For example,

char letter = 'a';

Here, `a` is the character literal.

We can also use escape sequences as character literals. For example, **\b** (backspace), **\t** (tab), **\n** (new line), etc.

A string literal is a sequence of characters enclosed inside double-quotes. For example,

String str1 = "Java Programming";

String str2 = "Javaistic";

Here, `Java Programming` and `Javaistic` are two string literals.