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 the 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 a convention to begin a variable
name with a letter. Also, variable names cannot use whitespace in Java.
 Variable
Naming Convention
 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 .
 If you choose 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,  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. For example,
 class BooleanExample {
public static void main(String[] args) {

boolean flag = true;

System.out.println(flag);
}
}

Output:

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);
}
}

Output:
 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 a minimum value of 0 and a 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);
}
}

Output:

-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 a minimum value of 0 and a maximum value of 264-1.
 Default value: 0

 Example:

class LongExample {
public static void main(String[] args) {

long range = -42332200000L;

System.out.println(range);
}
 }

Output:

-42332200000

Notice, the use of  L  at the end of  -42332200000 . This represents that it's an
integral literal of the  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);
}
}

Output:

-42.3
 float

 The  float  data type is a single-precision 32-bit floating-point. Learn

more about single-precision and double-precision floating-point if you are
interested.
 It should never be used for precise values such as currency.

 Default value: 0.0 (0.0f)

 Example:

class FloatExample {
public static void main(String[] args) {

float number = -42.3f;

System.out.println(number);
}
}

Output:

-42.3

Notice that, we have used  -42.3f  instead of  -42.3 in the above program. It's
because  -42.3  is a  double  literal. To tell the 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 the char data type is  '\u0000'  (0). The
maximum value of the char data type is  '\uffff' .
 Default value:  '\u0000'
 Example:
class CharExample {
public static void main(String[] args) {

char letter = '\u0051';

System.out.println(letter);
}
}

Output:

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);

}
}

Output:

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 the character as an integral type. To learn
more about ASCII, visit What is ASCII Code?.
 String

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 a 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 appear 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 the 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

 int 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;

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

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

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);
}
}

Output:

3.4
3.4
344.5

Character and String Literals

 They contain Unicode (UTF-16) characters.

 For  char  literals, single quotations are 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);
}
}

Output:

Java 8