Java Variables Types
The following are the three types of Java variables:
1. Local variables
2. Instance variables
3. Class/Static variables
1. Java Local Variables
Local variables are declared in methods, constructors, or blocks.
Local variables are created when the method, constructor or block is entered and
the variable will be destroyed once it exits the method, constructor, or block.
Access modifiers cannot be used for local variables.
Local variables are visible only within the declared method, constructor, or
block.
Local variables are implemented at stack level internally.
There is no default value for local variables, so local variables should be declared
and an initial value should be assigned before the first use.
Example 1: Variable's local scope with initialization
Here, age is a local variable. This is defined inside pupAge() method and its scope is
limited to only this method.
public class Test {
public void pupAge() {
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String args[]) {
Test test = new Test();
test.pupAge();
}
}
Output
Puppy age is: 7
Example 2: Variable's local scope without initialization
Following example uses age without initializing it, so it would give an error at the
time of compilation.
public class Test {
public void pupAge() {
int age;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String args[]) {
Test test = new Test();
test.pupAge();
}
}
Output
Test.java:4:variable number might not have been initialized
age = age + 7;
^
1 error
2. Java Instance Variables
Instance variables are declared in a class, but outside a method, constructor or any
block.
When a space is allocated for an object in the heap, a slot for each instance
variable value is created.
Instance variables are created when an object is created with the use of the
keyword 'new' and destroyed when the object is destroyed.
Instance variables hold values that must be referenced by more than one method,
constructor or block, or essential parts of an object's state that must be present
throughout the class.
Instance variables can be declared in class level before or after use.
Access modifiers can be given for instance variables.
The instance variables are visible for all methods, constructors and block in the
class. Normally, it is recommended to make these variables private (access level).
However, visibility for subclasses can be given for these variables with the use of
access modifiers.
Instance variables have default values. For numbers, the default value is 0, for
Booleans it is false, and for object references it is null. Values can be assigned
during the declaration or within the constructor.
Instance variables can be accessed directly by calling the variable name inside the
class. However, within static methods (when instance variables are given
accessibility), they should be called using the fully qualified
name. ObjectReference.VariableName.
Example of Java Instance Variables
import java.io.*;
public class Employee {
// this instance variable is visible for any child class.
public String name;
// salary variable is visible in Employee class only.
private double salary;
// The name variable is assigned in the constructor.
public Employee (String empName) {
name = empName;
}
// The salary variable is assigned a value.
public void setSalary(double empSal) {
salary = empSal;
}
// This method prints the employee details.
public void printEmp() {
System.out.println("name : " + name );
System.out.println("salary :" + salary);
}
public static void main(String args[]) {
Employee empOne = new Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}
Output
name : Ransika
salary :1000.0
3. Java Class/Static Variables
Class variables also known as static variables are declared with the static keyword
in a class, but outside a method, constructor or a block.
There would only be one copy of each class variable per class, regardless of how
many objects are created from it.
Static variables are rarely used other than being declared as constants. Constants
are variables that are declared as public/private, final, and static. Constant
variables never change from their initial value.
Static variables are stored in the static memory. It is rare to use static variables
other than declared final and used as either public or private constants.
Static variables are created when the program starts and destroyed when the
program stops.
Visibility is similar to instance variables. However, most static variables are
declared public since they must be available for users of the class.
Default values are same as instance variables. For numbers, the default value is 0;
for Booleans, it is false; and for object references, it is null. Values can be assigned
during the declaration or within the constructor. Additionally, values can be
assigned in special static initializer blocks.
Static variables can be accessed by calling with the class
name ClassName.VariableName.
When declaring class variables as public static final, then variable names
(constants) are all in upper case. If the static variables are not public and final, the
naming syntax is the same as instance and local variables.
Example of Java Class/Static Variables
import java.io.*;
public class Employee {
// salary variable is a private static variable
private static double salary;
// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";
public static void main(String args[]) {
salary = 1000;
System.out.println(DEPARTMENT + "average salary:" + salary);
}
}
Output
Development average salary:1000
Loop Statement
A loop statement allows us to execute a statement or group of
statements multiple times
Java Loops
Java programming language provides the following types of loops to
handle the looping requirements:
Sr.N
Loop & Description
o.
while loop
1
Repeats a statement or group of statements while a given condition is true. It tests
the condition before executing the loop body.
for loop
2
Execute a sequence of statements multiple times and abbreviates the code that
manages the loop variable.
do...while loop
3
Like a while statement, except that it tests the condition at the end of the loop
body.
Loop Control Statements
Loop control statements change execution from its normal sequence.
When execution leaves a scope, all automatic objects that were created in
that scope are destroyed.
In Java, the following are the loops control statements:
Sr.N
Control Statement & Description
o.
break statement
1
Terminates the loop or switch statement and transfers execution to the
statement immediately following the loop or switch.
2 continue statement
Causes the loop to skip the remainder of its body and immediately retest its
condition prior to reiterating.
Java while Loop
Java while loop statement repeatedly executes a code block as long as a
given condition is true.
The while loop is an entry control loop, where conditions are checked
before executing the loop's body.
Syntax of while Loop
The syntax of a while loop is −
while(Boolean_expression) {
// Statements
}
Execution Process of a while Loop
Here, statement(s) may be a single statement or a block of statements.
The condition may be any expression, and true is any non-zero value.
When executing, if the boolean_expression result is true, then the actions
inside the loop will be executed. This will continue as long as the
expression result is true.
When the condition becomes false, program control passes to the line
immediately following the loop.
Flow Diagram
The following diagram shows the flow diagram (execution process) of a
while loop in Java -
Here, key point of the while loop is that the loop might not ever run. When
the expression is tested and the result is false, the loop body will be
skipped and the first statement after the while loop will be executed.
Examples of while Loop
Example 1: Printing Numbers in a Range Using while Loop
In this example, we're showing the use of a while loop to print numbers
starting from 10 to 19. Here we've initialized an int variable x with a value
of 10. Then in while loop, we're checking x as less than 20 and within
while loop, we're printing the value of x and incrementing the value of x
by 1. While loop will run until x becomes 20. Once x is 20, loop will stop
execution and program exits.
exits.
Open Compiler
public class Test {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}
}
Output
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
Example 2: Printing Elements of an Array Using while Loop
In this example, we're showing the use of a while loop to print contents of
an array. Here we're creating an array of integers as numbers and
initialized it some values. We've created a variable named index to
represent index of the array while iterating it. In while loop we're checking
the index to be less than size of the array and printed the element of the
array using index notation. index variable is incremented by 1 and loop
continues till index becomes the size of the array and loop exits.
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
int index = 0;
while( index < 5 ) {
System.out.print("value of item : " + numbers[index] );
index++;
System.out.print("\n");
}
}
}
Output
value of item : 10
value of item : 20
value of item : 30
value of item : 40
value of item : 50
Infinite While Loop
You can implement an infinite while loop using the while loop statement
by providing "true" as the test condition.
Example: Implementing Nested while Loop
In this example, we're showing the infinite loop using while loop. It will
keep printing the numbers until you press ctrl+c to terminate the
program.
public class Test {
public static void main(String args[]) {
int x = 10;
while( true ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}
}
Output
value of item : 10
value of item : 20
value of item : 30
value of item : 40
value of item : 50
...
ctrl+c
