Java Variables and (Primitive) Data Types

In this tutorial, you will learn about variables, how to create them, and different data types that Java programming language supports for creating variables.

Java Variables

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.


How to declare variables in Java?

Here's an example to declare a variable in Java.

int speedLimit = 80;

Here, speedLimit is a variable of int data type, and is assigned value 80. Meaning, the speedLimit variable can store integer values. You will learn about Java data types in detail later in the article.

In the example, we have assigned value to the variable during declaration. However, it's not mandatory. You can declare variables without assigning the value, and later you can store the value as you wish. For example,

int speedLimit;
speedLimit = 80;

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

int speedLimit = 80;
... .. ...
speedLimit = 90; 

Java is a statically-typed language. It means that all variables must be declared before they can be used.

Also, you cannot change the data type of a variable in Java within the same scope. What is variable scope? Don't worry about it for now. For now, just remember you cannot do something like this.

int speedLimit = 80;
... .. ...
float speedLimit;

To learn more, visit: Can I change declaration type for a variable in Java?


Rules for Naming Variables in Java

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

  • Variables in Java are case-sensitive.
  • A variable's name is a sequence of Unicode letters and digits. It can begin with a letter, $ or _. However, it's convention to begin a variable name with a letter. Also, variable name cannot use whitespace in Java.
    Java variable naming convention
  • When creating variables, choose a name that makes sense. For example, score, number, level makes more sense than variable name such as s, n, and l.
  • If you choose one word variable name, use all lowercase letters. For example, it's better to use speed rather than SPEED, or sPEED.
  • If you choose variable name having more than one word, use all lowercase letters for the first word and capitalize the first letter of each subsequent word. For example, speedLimit.

There are 4 types of variables in Java programming language:

  • Instance Variables (Non-Static Fields)
  • Class Variables (Static Fields)
  • Local Variables
  • Parameters

You will learn about in later chapters. If you are interested to learn more about it now, visit Java Variable Types.


Java Primitive Data Types

As mentioned above, Java is a statically-typed language. This means that, all variables must be declared before they can be used.

int speed;

Here, speed is a variable, and the data type of the variable is int. The int data type determines that the speed variable can only contain integers.

In simple terms, a variable's data type determines the values a variable can store. There are 8 data types predefined in Java programming language, known as primitive data types.

In addition to primitive data types, there are also referenced data types in Java (you will learn about it in later chapters).

8 Primitive Data Types


boolean

  • The boolean data type has two possible values, either true or false.
  • Default value: false.
  • They are usually used for true/false conditions.
  • Example:
class BooleanExample {
    public static void main(String[] args) {
    	
    	boolean flag = true;
    	System.out.println(flag);
    }
}

When you run the program, the output will be:

true

byte

  • The byte data type can have values from -128 to 127 (8-bit signed two's complement integer).
  • It's used instead of int or other integer data types to save memory if it's certain that the value of a variable will be within [-128, 127].
  • Default value: 0
  • Example:
class ByteExample {
    public static void main(String[] args) {
    	
    	byte range;
    	
    	range = 124;
    	System.out.println(range);
    	
    	// Error code below. Why?
    	// range = 200
    }
}

When you run the program, the output will be:

124

short

  • The short data type can have values from -32768 to 32767 (16-bit signed two's complement integer).
  • It's used instead of other integer data types to save memory if it's certain that the value of the variable will be within [-32768, 32767].
  • Default value: 0
  • Example:
class ShortExample {
    public static void main(String[] args) {
    	
    	short temperature;
    	
    	temperature = -200;
    	System.out.println(temperature);
    	
    }
}

When you run the program, the output will be:

-200

int

  • The int data type can have values from -231 to 231-1 (32-bit signed two's complement integer).
  • If you are using Java 8 or later, you can use unsigned 32-bit integer with minimum value of 0 and maximum value of 232-1. If you are interested in learning more about it, visit: How to use the unsigned integer in java 8?
  • Default value: 0
  • Example:
class IntExample {
    public static void main(String[] args) {
    	
    	int range = -4250000;
    	System.out.println(range);
    }
}

When you run the program, the output will be:

-4250000

long

  • The long data type can have values from -263 to 263-1 (64-bit signed two's complement integer).
  • If you are using Java 8 or later, you can use unsigned 64-bit integer with minimum value of 0 and maximum value of 264-1.
  • Default value: 0
  • Example:
class LongExample {
    public static void main(String[] args) {
    	
    	long range = -42332200000L;
    	System.out.println(range);
    }
}

When you run the program, the output will be:

-42332200000

Notice, the use of L at the end of -42332200000. This represents that it's an integral literal of long type. You will learn about integral literals later in this article.


double

  • The double data type is a double-precision 64-bit floating point.
  • It should never be used for precise values such as currency.
  • Default value: 0.0 (0.0d)
  • Example:
class DoubleExample {
    public static void main(String[] args) {
    	
    	double number = -42.3;
    	System.out.println(number);
    }
}

When you run the program, the output will be:

-42.3

float

class FloatExample {
    public static void main(String[] args) {
    	
    	float number = -42.3f;
    	System.out.println(number);
    }
}

When you run the program, the output will be:

-42.3

Notice that, we have used -42.3f instead of -42.3in the above program. It's because -42.3 is a double literal. To tell compiler to treat -42.3 as float rather than double, you need to use f or F.


char

  • It's a 16-bit Unicode character.
  • The minimum value of char data type is '\u0000' (0). The maximum value of char data type is '\uffff'.
  • Default value: '\u0000'
  • Example:
class CharExample {
    public static void main(String[] args) {
    	
    	char letter = '\u0051';
    	System.out.println(letter);
    }
}

When you run the program, the output will be:

Q

You get the output Q because the Unicode value of Q is '\u0051'.

Here is another example:

class CharExample {
    public static void main(String[] args) {
    	
    	char letter1 = '9';
    	System.out.println(letter1);
    	
    	char letter2 = 65;
    	System.out.println(letter2);

    }
}

When you run the program, the output will be:

9
A

When you print letter1, you will get 9 because letter1 is assigned character '9'.

When you print letter2, you get A because the ASCII value of 'A' is 65. It's because java compiler treats character as integral type. Learn more about ASCII.


Java also provides support for character strings via java.lang.String class. Here's how you can create a String object in Java:

myString = "Programming is awesome";

Java String is an important topic which you will learn in detail in later chapters. However, if you are not a newbie in programming and want to learn it now, visit Java String.


Java literals

To understand literals, let's take an example to assign value to a variable.

boolean flag = false;

Here,

  • boolean - is data type.
  • flag - is variable
  • false - is literal.

A Literal is the source code representation of a fixed value.

Values like 1.5, 4, true, '\u0050' that appears directly in a program without requiring computation are literals.

In the above example, flag is a variable. Since, it's a boolean type variable, it may store either false or true. For compiler to understand it, it requires computation. However, literals like -5, 'a', true represents fixed value.


Integer Literals

  • Integer literals are used to initialize variables of integer data types byte, short, int and long.
  • If an integer literal ends with l or L, it's of type long. Tip: it is better to use L instead of l.
    // Error! literal 42332200000 of type int is out of range
    long myVariable1 = 42332200000;
    
    // 42332200000L is of type long, and it's not out of range
    long myVariable2 = 42332200000L;
    
  • Integer literals can be expressed in decimal, hexadecimal and binary number systems.
  • The numbers starting with prefix 0x represents hexadecimal. Similarly, numbers starting with prefix 0b represents binary.
    // decimal
    int decNumber = 34;
    
    // 0x represents hexadecimal
    int hexNumber = 0x2F;
    
    // 0b represents binary
    int binNumber = 0b10010;

Floating-point Literals

  • Floating-point literals are used to initialize variables of data type float and double.
  • If a floating-point literal ends with f or F, it's of type float. Otherwise, it's of type double. A double type can optionally end with D or d. However, it's not necessary.
  • They can also be expressed in scientific notation using E or e.

class DoubleExample {
    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);
    	System.out.println(myFloat);
    	System.out.println(myDoubleScientific);
    }
}

When you run the program, the output will be:

3.4
3.4
344.5

Character and String Literals

  • They contain Unicode (UTF-16) characters.
  • For char literals, single quotation is used. For example, 'a', '\u0111' etc.
  • For String literals, double quotation is used. For example, "programming", "Java 8"
  • Java also supports a few special escape sequences. For example, \b (backspace), \t (tab), \n (line feed), \f (form feed), \r (carriage return), \" (double quote), \' (single quote), and \\ (backslash).
class DoubleExample {
    public static void main(String[] args) {
    	
    	char myChar = 'g';
    	char newLine = '\n';
    	String myString = "Java 8";
    	
    	System.out.println(myChar);
    	System.out.println(newLine);
    	System.out.println(myString);
    }
}

When you run the program, the output will be:

g


Java 8