Introduction to Java : Data Types and Operators Part-2

Data Types

Java is a “strongly typed language”. That means that type of every variable must be declared.

Consider the following simple variable assignments:

In other words, Java requires that if a variable is meant to hold a boolean, it is declared as such. The same goes for ints and every other data type.

Once you declare a variable, it can never be changed to hold another type of value.

In Java, there are eight types of variables: int, short, long, byte, float, double, char, and boolean.

Let’s look at each one of these so we can better understand what they are.

Declaring, Assigning, and Casting Variables

Declaring Variables

As we just said, if you want to use a variable, you must specifically declare its type. To declare a variable’s type you simply use the type followed by the variable name. Consider the following examples:

byte b; short age; long nationalDebt; boolean isMale;

1 2 3 4

byte b; short age; long nationalDebt; boolean isMale;

You can also declare multiple variables of one type in one expression such as in the following example:

int age, yrsEmployed, numChildren;

1	int age, yrsEmployed, numChildren;

Variable Assignment and Initialization

Once you have declared the type of a variable, you are free to initialize it and assign to it some value.

Assignment and initialization is simple. You simply use variable name = some value. For example, consider the following code:

int age; age = 28;

1 2	int age; age = 28;

Of course you can also declare variables and assign values to them at the same time using the following syntax:

int age = 28;

1	int age = 28;

Casting (Changing from one type to another)

What if you want to multiply 2 x 1.5? Or more generically, int x double? Will the result be an int or a double or something else?

Well, when in doubt, Java will convert to the less restrictive type to be safe. Thus, in the above example, the result will be a double since double is less restrictive.

The following chart shows how types will be caste if possible.

However, what if you are going the other way? Suppose you have two doubles and you want to make an int out of the product

To do this type of caste, you simply perform an assignment using the type to be casted to in parentheses before the value to be casted. Consider the following example in which we caste from a double to an int:

In this case, it will be assigned a value of “123”.

Variable Type Helper Objects

So far, the variable types we have discussed are called “primitive types” because they represent simple values that have built-in characteristics. They are fixed elements. Java also provides a set of “reference types” that include object arrays, strings, and other more complex data structures.

We’ll talk more about reference types later when we are using them. However, it is good to note that Java provides reference “wrapper” types for each primitive type that include manipulative functionality.

These classes can all be found in java.lang and include: Boolean, Character, Double, Float, Integer, Long, and String.

Each class contains helper methods that allow you to more easily work with the values. One of the most useful features provided by the wrapper classes is the ability to easily change from one type to another. Thus, you can change an integer value to its string representation using something like:

Consider the list of methods in the following objects: