2.1 Introduction

Most of the concepts of Java programming language are similar to C/C++. The main advantage of Java is that it is fully object-oriented. The main objective of this chapter is to give you experience in compiling and running Java programs, introduce variables in Java, and introduce some of the primitive types in Java.

2.2 Variable declarations

The general format of variable declaration is

type varname;

Java is a strongly typed language. There are eight simple types of data: bytes, short, int, long char, float, double, and Boolean. These can be put into four groups.

2.2.1 Integers: Integer variables store whole numbers without decimals. They can be positive or negative numbers. There are four types of integers: long, int, short and byte.

Type	Size in bits	Size in bytes
long	64 bits	8 bytes
int	32 bits	4 bytes
short	16 bits	2 bytes
byte	8 bits	1 byte

2.2.2 Floating point numbers: These variables  represent numbers with fractional precision.

Type	Size in bits	Size in bytes
float	32 bits	4 bytes
double	64 bits	8 bytes

2.2.3 Characters: A character variable size is 2 bytes. Java char type denotes characters in the Unicode encoding scheme. Unicode is a system of encoding. It is designed to handle almost all characters in all written languages of the world. The first 255 characters of this Unicode correspond to ASCII code.

Examples for variable declaration

byte a;     // a is defined as a byte

int b,c,d; //b,c,d are integers

char e,f;  // e,f are characters

2.2.4 Booleans: Boolean variable is used for logical values. It can have only two values, true or false.

 Program 2.1 Printing boolean values

//booleanDemo.java

//click here for code

public class booleanDemo {
public static void main(String[] args) {
  System.out.println("Hello World");
  boolean var1 = true;
  boolean var2 = false;
  System.out.println(var1); // Outputs true
  System.out.println(var2); // Outputs false } }

//Output: 
//true 
//false

** Java is case sensitive.

2.3 Scope and lifetime of variables

2.3.1 Scope of a variable

A variable’s scope is the block within which the variable is accessible, Also a variable scope decides when a variable is created and destroyed.

As a general rule, variable declared inside a scope is not visible to code that is defined outside that scope. Scopes can be nested. Outer scope encloses the inner scope. However, the reverse is not true. Objects declared within the inner scope will not be visible outside it.

The scope is demonstrated in the program 2.2.

Program 2.2  Program demonstrating scope.

//scopeDemo.java
//Click here for code

//Output:
a=5 b=20
a is 40

2.3.2 Lifetime of a variable

Lifetime of a variable occupies a significant portion of the programming effort. How long does the variable last? If you are supposed to destroy it, when should you? Java greatly simplifies the work by doing the entire clean up for us.

Program 2.3. Program to demonstrate lifetime of variable.

//lifedemo.java 
//Click here for code 
class lifedemo { 
public static void main(String args[]) 
{ 
  int i,j; for(j=0; j<3;j++) 
  { 
   i=1; 
   System.out.println(i= +i); 
   i=100; 
   System.out.println(i= +i); 
  } 
} 
}
//Output:
1
100
1
100
1
100

i is initialized with 1 and then with 100 and i is again initialized with 1 and this repeats all three times. This is because, the lifetime of variable is within that block only.

2.4 Operator overloading

Although operator overloading would have been much simpler to implement in Java than it was in C++, this feature was considered still too complex. Java does not support Operator Overloading except for one case i.e “+” operator it can be used to add number as well as strings.

2.4.1 String operators+

If an expression begins with a String, then all operands that follow must be strings. Program 2.4 demonstrates that + operator  can be overloaded to concatenate strings. Overloading means the operator can perform multiple operations. Here +operator is able to concatenate strings and numbers. Note that addition is not being done on numbers a, b and c but their values are concatenated.

Program 2.4. Program to demonstrate +operator

//stringOp.java
//click here for code
public class stringOp
{
 public static void main(String[] args) {
 System.out.println("Hello World");
 int a=0,b=1,c=2;
 String s="a,b,c";
 System.out.println(s+a+b+c);
 }
}

//Output:

a,b,c012

2.5 Size of data types in Java

In C and C++, the sizeof() operator satisfies a specific need. It tells the number of bytes allocated for data items. All the data types in Java are of the same size on all machines. We need not think about portability.

2.6 Type conversions and casting

2.6.1 Automatic conversion and casting

When one type of data is assigned to another type of a variable, automatic type conversion will take place. This is also called as implicit type conversion. For widening conversions, the numeric types including integer and floating point types are compatible with each other. However, numeric types are not compatible with char or boolean, char and boolean are not compatible with each other. There are two types of casting, namely widening and Narrowing.

a) Widening Casting : convert a smaller type to a larger type size
byte -> short -> char -> int -> long -> float -> double

b) Narrowing Casting : convert a larger type to a smaller size type
double -> float -> long -> int -> char -> short -> byte

2.6.2 Casting incompatible types

General form of casting incompatible types is

(Target-type) value;

Target-type specifies the desired type to convert the specified value to. The following are few examples for typecasting.

int a; byte b;
double pi=3.1412;
int x=(int)pi; //outputs 3
a=1
b=(byte) a;    // outputs 1

Program 2.5 shows how to typecast from double to int.

Program 2.5 Program to demonstrate type casting

//typeCasting.java
//click here for code
public class typeCasting
{
 public static void main(String[] args) {
    System.out.println("Hello World");
    int wide_mark = 85;
    double wide_money = wide_mark; // casting int to double
    System.out.println(wide_mark);      
    System.out.println(wide_money); 
    double narrow_money=85.0;
    int narrow_mark;
    narrow_mark=(int)narrow_money; //type cast
    System.out.println(narrow_mark);      
    System.out.println(narrow_money);
 }
}
//Output:
85
85.0
85
85.0

2.7 Constants

These values can not be changed during the program’s execution.

Example:

//num is a variable of type double
static final double num 1.40;

Setting a variable to final will prevent it from being overridden and cannot be modified.

The variable num is declared as static. That means num variable belongs to the class where it is defined. Even if an instance(object) is created for this class, it will not belong to that instance. In other words, there can be only one copy of the variable num in main memory. Functions can also be declared static. An example is given in Chapter 1.

2.8 Operators

Operators are two types.

Unary operators: Operators requiring one operand. Example:  ++.

Binary operators: Operators that require two operands. Examples: +, – 

2.8.1 Arithmetic operators

Operators like +,-,*,/,% are arithmetic operators.

Operator	Description
+	Addition:  c=a+b
–	Subtraction: c=a-b
*	Multiplication: c=a*b
/	Division: c=a/b
%	Reminder after division: c=a%b

2.8.2 Exponentiation

There is no ‘^’ sign. The function pow() must be used. It is built in java.lang package.

2.8.3 Increment and Decrement operators(++,–)

Increment and decrement operators are the additional arithmetic operators. Consider the following statements.

i++; //i is incremented after operation,

m–; //m is decremented after operation,

++j; //j is incremented before operation,

–n; //n is decremented before operation.

2.8.4 Bitwise operators

2.9 Parenthesis and operator hierarchy

2.10 Relational Operators ( Comparison)

2.11 Expressions

An expression is a collection of variables and operators that specify a computation. Expressions are used to perform operations on the data in program.

For example,

c=a+b;

In the above example a+b is an expression, the result is computed and is assigned to c.

2.12 Summary

You have been introduced to the variables, expression, operators, scope, lifetime of variables. In the next chapters we will be using these concepts.