ExamDirectory

Java is a robust language. One of the factors, which makes Java robust is the fact that it is a strongly typed language, i.e., every variable has a type, every expression has a type, and every type is defined.Java defines eight primitive data types. These are as follows:

1. int
2. byte
3. long
4. short
5. float
6. char
7. boolean
8. double

These can be grouped into four main categories as listed below:

• Integers: This includes int, long, short , and byte.
• Floating-point numbers: This includes float and double. These represent numbers with fractional precision.
• Characters: The char type is included in this category.
• Boolean: The boolean is a special type to represent true/false values.

The width and range of each type is given below:

Type	Width	Range
byte	8-bit	-128 to 127
short	16-bit	-32,768 to 32,767
int	32-bit	-2,147,483,648 to -2,147,483,647
long	64-bit	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float	32-bit	1.4e-045 to 3.4e+038
double	64-bit	4.9e-324 to 1.8e+308
char	16-bit	‘\u0000′ to ‘\uffff ‘

Type Conversion and Type Casting

Java provides two kinds of data type conversions automatic and explicit. Automatic conversion takes place when the following two conditions are fulfilled:

• The two types are compatible.
• The destination type is larger than the source type.

When these two conditions are met, widening conversion takes place, i.e., a narrow data type is promoted to a wider one. For example, value of byte type will be promoted to int, as int is wider than byte in width.

In many cases automatic type conversions are helpful, but they fail to fulfill all the requirements. For example, an automatic conversion cannot be performed to convert int to byte, as int is wider than byte. The general form to perform such type of narrowing conversion is as follows:

(target-type) value

The example below describes an explicit conversion:

class Rat {
public static void main(String args[]){
int a=10,b=20;
byte c;
c= (byte)(a+b);
System.out.print(c);
}
}

here, the value obtained after adding variables a and b of int type is stored in c, which is of byte type. Therefore, before storing the value casting is done:

c= (byte)(a+b);

Variable

A variable is said to be a storage unit in Java. A variable is defined as the combination of an identifier, a type, and an optional initializer. Every variable has a scope, which defines its visibility, and a lifetime.

Variable Declaration:

The general form for declaring a variable in Java, is as follows:

type identifier[=value];

In the line mentioned above, type defines the data type of a variable. It can be int, short, char, etc. The identifier refers to the name of the variable, and the value is any constant assigned to a variable. The variable declaration must end with a semicolon “;”. Java keywords such as final, try, etc. are not allowed as variable names. Some examples given below describe variable declaration in detail:

int a, b, c; // declaration of three variables a, b, and c of int type.

int a=3, b; // declaration of two variables a and b and initialization of a.

char x=’x'; // declares char type variable and assigns value. The char type value must be within single quotes.

Dynamic Initialization of Variables :

The example given below describes the dynamic initialization:

class Dynamic {
public static void main(String args[]) {
int a=10, b=30;
double c=a+b; //dynamic initialization of variable c
System.out.print(c);
}
}

In the example given above, the variable c is dynamically assigned the value obtained after the addition of values stored in variables ‘a’ and ‘b’.

The Scope and Lifetime of a Variable

In the example mentioned above, all the variables are declared within the main method. However, Java allows a variable declaration within any block. An opening and closing brace defines a block. This is a block:

{

//block

}

A block defines a scope. A scope determines the visibility and lifetime of an object, which is defined inside it.

The other programming languages such as C defines two categories of scopes: global and local. These two traditional categories do not gel well with Java’s strict object-oriented model. In Java, the two main scopes are those that are defined by a class and a method.

The scope defined by a method begins with an opening brace and finishes with a closing brace. The parameters of a method are also within that scope.

As a rule, the variables declared inside a scope are only visible to the code within that scope. These variables are not visible to the code outside the scope. Therefore, declaring a variable inside a scope localizes it and prevents it from unauthorized access or modification.

Nested scopes are allowed, i.e., a scope within a scope. For example, each time a programmer creates a block of code, he creates a new, nested scope. When this happens, the outer scope encloses the inner scope. This means that objects declared in the outer scope will be visible to the code within the inner scope but not vice-versa. Objects declared inside the inner scope will not be visible to the outer scope.

The example below describes the nested scope:

class Nested {
public static void main(String args[]) {
int x; //visible to all code within main()
x=100;
if (x==100) { //start of new scope
int y=20; // known only within this block
//x and y both known here
System.out.println(+x + ” ” +y);
}
y=200; // error, as y is not known here
System.out.print(x) // x is known here
}
}

here, the variable x is declared at the start of the main() method’s scope and is accessible to all the subsequent code within the main method. The variable y is declared within the if block and is accessible within this block. That is why a compile-time error will be generated if y is initialized to 200.

Note : A variable is created when its scope is entered, and gets destroyed when its scope ends. This means that a variable will not hold its value once it has gone out of scope.

Array

An array is a group of variables of the same data type referred to by a common name. Arrays of any data type can be created and may have one or more dimensions. A particular element in an array is accessed by its index.

One Dimensional Array

A one-dimensional array is a list of variables of the same data type. The general form for creating a one-dimensional array is:

type var-name[]; or type[] var-name;

here, type refers to the data type of an array, and var-name refers to the name of the array.

For example,

int arr[];

This declares an empty array named arr of int type. In Java, the size of an array is set when it is explicitly created using the new operator.

int arr[]= new int [5];

It will create an array named arr of size 5. It will store 5 elements, from 0 to 4. The starting index of an array is 0.

The diagram below depicts a conceptual view of the array declared above:

here, each box will contain one element.

The first element of the array is positioned at the 0^th location, therefore, to get the value of the first element, the following code is used:

System.out.print(arr[0]);

Note: In Java, the elements of an array are always set to default values after their creation. An int type array is set to 0 and a boolean type array contains false by default if no value is stored in an array.

Multidimensional Arrays

In Java, a multidimensional array is known as an array of arrays. The general form for declaring a multidimensional array:

type var-name[][]; or type[][] var-name;

like a one dimensional array, the size of a two dimensional array is also explicitly created using the new operator. The example below describes this:

int a[][]=new a[3][2];

This will create an array, which contains 3 rows and 2 columns. It will contain 3*2, i.e., 6 elements. The first index is [0][0] and the last index is [2][1]

Array size

In Java, the length field specifies the size of an array.

The example below describes its use.

class Rat {
public static void main(String args[]) {
int a[]=new int[4];
System.out.print(a.length);

here, the output will be 4.

What is an ArrayIndexOutOfBoundsException?

In Java, a run-time error ArrayIndexOutOfBoundsException is encountered when a program attempts to extract a value from an array outside its boundary. For example,

1. class Rat {
2. public static void main(String args[]) {
3. int a[]=new int[4];
4. System.out.print(a[5]);