Variables:
* A Java variable is a piece of memory that can contain a data value. A variable thus
has a data type.
* Variables are typically used to store information which your
Java program needs to do its job.
Type Of Variables:
* Local Variable
* Instance Variable
* Static Variable
Examples Of Variable Declaration And Initialization
In Java:
int a, b, c;
// Declares
three ints, a, b, and c.
int a = 10, b = 10;
// Example of initialization
byte B = 22;
// initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';
// the char variable a iis initialized with
value 'a'
Local variable:
* A variable that is declared within the method, constructor,
or block is known as local variable.
* 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.
Syntax of Local Variable
type varName = value;
Example of Local Variable
Example 1 : Program that illustrates
the local variables and it's scope
class Sample
{
static
ctr = 0;
int
i = 100;
void display1()
{
System.out.println("Before");
System.out.println("ctr = " + ctr);
System.out.println("i = " + i);
int ctr = 2, i = 200; // LOCAL VARIABLE
System.out.println("");
System.out.println("After");
System.out.println("ctr = " + ctr);
System.out.println("i = " + i);
}
void display2()
{
System.out.println("Another method");
System.out.println("ctr = " + ctr);
System.out.println("i = " + i);
}
}
class LocalVariables
{
public
static void main(String args[])
{
Sample sObj = new Sample();
sObj.display1();
System.out.println("");
sObj.display2();
}
}
OUTPUT:
Before
ctr = 0
i = 100
After
ctr = 2
i = 200
Another method
ctr = 0
i = 100
Instance
variables
* Instance variables are declared
in a class, but outside a method,
constructor or any block.
* 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 can be accessed directly by calling the variable
name inside the class. However within static methods and different class (when
instance variables are given accessibility) should be called using the fully
qualified name.
* 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.
Example of Instance Variable
Example 2 : Program that illustrates the 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
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.
* 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 static memory.
* Static variables are created when the program starts and
destroyed when the program stops.
* The Static 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.
* Static 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.
Example of Static Variable
Example 3 : Program that illustrates the 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
This is dummy text. It is not meant to be read. Accordingly, it is difficult to figure out when to end it. But then, this is dummy text. It is not meant to be read. Period.
ConversionConversion EmoticonEmoticon