Java Data Types
As explained in the text about Java variables, each variable in Java has a data type. Data types into two groups:
- Primitive data types
- Object references
A variable takes up a certain amount of space in memory. How much memory a variable takes depends on its data type.
A variable of a primitive data type contains the value of the variable directly in the memory allocated to the variable. For instance, a number or a character.
A variable of an object reference type is different from a variable of a primitive type. A variable of an object type is also called a reference. The variable itself does not contain the object, but contains a reference to the object. The reference points to somewhere else in memory where the whole object is stored. Via the reference stored in the variable you can access fields and methods of the referenced object. It is possible to have many different variables reference the same object. This is not possible with primitive data types.
Primitive Data Types
The Java language contains the following primitive data types:
|boolean||A binary value of either
|byte||8 bit signed value, values from -128 to 127|
|short||16 bit signed value, values from -32.768 to 32.767|
|char||16 bit Unicode character|
|int||32 bit signed value, values from -2.147.483.648 to 2.147.483.647|
|long||64 bit signed value, values from -9.223.372.036.854.775.808 to 9.223.372.036.854.775.808|
|float||32 bit floating point value|
|double||64 bit floating point value|
That these are primitive data types means that they are not objects, nor references to objects (classes and objects are explained in later texts in this Java tutorial).
Here is an example of how you declare a variable of a primitive type:
The primitive types also come in versions that are full-blown objects. That means that you reference them via an object reference, that you can have multiple references to the same value, and you can call methods on them like on any other object in Java. The list of core object data types below contains the object versions of the primitive types. The list also contains a few other of the core object types in Java.
|Boolean||A binary value of either
|Byte||8 bit signed value, values from -128 to 127|
|Short||16 bit signed value, values from -32.768 to 32.767|
|Character||16 bit Unicode character|
|Integer||32 bit signed value, values from -2.147.483.648 to 2.147.483.647|
|Long||64 bit signed value, values from -9.223.372.036.854.775.808 to 9.223.372.036.854.775.808|
|Float||32 bit floating point value|
|Double||64 bit floating point value|
|String||N byte Unicode string of textual data. Immutable|
Notice how object types are spelled with a capital letter in the beginning of their name, where the primitive
version (non-object) is spelled in all lowercase characters. There are also abbreviation differences, like
There are of course many other components you can use in the Java API, but the above mentioned data types are the core Java types. The String type is explained in more detail in its own text: Java Strings.
You can also create your own more complex data types by creating custom classes. I will get back to how in a later text.
Here is how you declare a variable of (reference to) one of the core object types:
When you declare an object reference variable, the reference does not point to any object. You need to create (instantiate) an object first. Here is how that is done:
Integer myInteger; myInteger = new Integer(45);
This example makes the
myInteger variable reference an
Integer object which internally
contains the value 45. It is the
new Integer(45) part of the code that creates the
You can also create the object already when the variable is declared, like this:
Integer myInteger = new Integer(45);
Object Versions of Primitive Data Types Are Immutable
The object versions of the primitive data types are immutable, meaning the values stored inside them cannot be
changed once set. For instance, the value stored inside an
Integer object cannot be changed once the object has been created.
The variable that references the object can be made to point to another object though. Here is an example:
Integer myInteger = new Integer(45); myInteger = new Integer(33);
As you can see, the variable in the example is made to point to another
Before Java 5 you had to call methods on the object versions of the primitive types, to get their value out as a primitive type. For instance:
Integer myInteger = new Integer(45); int myInt = myInteger.intValue();
From Java 5 you have a concept called "auto boxing". That means that Java can automatically "box" a primitive variable in an object version, if that is required, or "unbox" an object version of the primitive data type if required. For instance, the example before could be written like this:
Integer myInteger = new Integer(45); int myInt = myInteger;
In this case Java would automatically extract the
int value from the
and assign that value to
Similarly, creating an object version of a primitive data type variable was a manual action before Java:
int myInt = 45; Integer myInteger = new Integer(myInt);
With auto boxing Java can do this for you. Now you can write:
int myInt = 45; Integer myInteger = myInt;
Java will then automatically "box" the primitive data type inside an object version of the corresponding type.
Java's auto boxing features enables you to use primitive data types where the object version of that data type
was normally required, and vice versa. There is one pitfall to keep in mind though. A variable of type object
(a reference to an object) can point to
null, meaning it points to nothing - no object. If you try
null to a primitive value you will get a
NullPointerException (an error that
causes the program to fail). This code shows an example of that:
Integer myInteger = null; int myInt = myInteger;
This code will compile alright, but when executed it will result in a
myInteger points to
null. It is thus not possible to convert (unbox) the
value of the object it points to, because it does not point to any object.