Java has three kinds of variables: local (automatic) instance and class. Local variables are declared within a method body. Both instance and class variables are declared inside a class body but outside of any method bodies. Instance and class variables look similar except class variables are prepended with the static modifier.

class someClass {

// Instance Variable
visibility_modifier variable_type instanceVariableName;

// Class Variable
visibility_modifier static variable_type classVariableName;

returnType someMethod() {

// Local Variable
variable_type localVariableName;
}
}

Thanks for your explination.

local variable is a variable declared inside a method whereas instance variable is declared at classlevel. if wrong plz advice

There are three kinds of Java variables:

1. Local variables are declared in a method constructor or block. When a method is entered an area is pushed onto the call stack. This area contains slots for each local variable and parameter. When the method is called the parameter slots are initialized to the parameter values. When the method exits this area is popped off the stack and the memory becomes available for the next called method. Parameters are essentially local variables which are initialized from the actual parameters. Local variables are not visible outside the method.
2. Instance variables are declared in a class but outside a method. They are also called member or field variables. When an object is allocated in the heap there is a slot in it for each instance variable value. Therefore an instance variable is created when an object is created and destroyed when the object is destroyed. Visible in all methods and constructors of the defining class should generally be declared private but may be given greater visibility.
3. Class/static variables are declared with the static keyword in a class but outside a method. There is only one copy per class regardless of how many objects are created from it. They are stored in static memory. It is rare to use static variables other than declared final and used as either public or private constants.