What is the difference between local and instance variables in Java?

Except the scope and the storage differences, are there any other major difference between instance and l开发者_开发知识库ocal variables in Java?

The main differences that I see are in their:

Scope: Local variables are visible only in the method or block they are declared whereas instance variables can been seen by all methods in the class.

Place where they are declared: Local variables are declared inside a method or a block whereas instance variables inside a class, but outside a method.

Existence time: Local variables are created when a method is called and destroyed when the method exits whereas instance variables are created using new and destroyed by the garbage collector when there aren't any reference to them.

Access: You can't access local variables, whereas instance variables can be accessed if they are declared as public.

Where they are declared: Local variables are declared in a method or a block before they are called, whereas instance variables can be declared anywhere in the class level (even after their use).

Instance variables always have value, even if they are not assigned by the code (then they will have for example null, 0, 0.0, and false). For local variables, there must be an assigned value by the code. Otherwise the compiler generates an error.

One extra thing I can think of:

Instance variables are given default values, i.e., null if it's an object reference, and 0 if it's an int.

Local variables don't get default values, and therefore need to be explicitly initialized (and the compiler usually complains if you fail to do this).

One other difference is you don't have to worry about concurrent access to local variables; whereas you do with instance variables in a multi-threaded environment.

No, you pretty much covered it. An instance variable belongs to an instance of a class, and a local variable belongs to a stack frame.

Instance variables are initialized to default values, but it's generally good practice to use explicit initializations anyway.

A local variable:

• is declared inside a method/constructor or within a block (enclosed in braces)
• must be initialized before use. Otherwise it won't compile.

An instance variable:

• is declared inside a class.
• initialization is not compulsory: if omitted, it contains the default value (0, 0.0, false, null, etc.)

-> local variable is declared in the body of a method and can be used only from the point at which it’s declared through the end of the method declaration.

-> An instance variable is declared in a class, but not in the body of any of the class’s methods. Also, instance variables are accessible to all methods of the class.

Aside from all that is already mentioned here, I would like to point out that local variables are a bit faster to access for the JVM. The JVM has got more work to do to read or write an instance variable compared to a a local variable.

This is still true for the current HotSpot server JVM, because it's not a VM optimization problem. It's rather caused by the fact that an instance variable is visible outside of the method and could thus be accessed from other threads while the method is executed.

Aside from all the differences mentioned in previous answers, I would like to point out one more difference that, instance variables can have access modifiers (like private, public, protected, etc.), but local variables will not have any access modifiers.

Local variables are on the stack, but member variables (instance variables) are on the heap.

Variables defined inside methods, constructors or blocks are called local variables. The variable will be declared and initialized within the method and it will be destroyed when the method has completed.

Instance variables are variables within a class but outside any method. These variables are instantiated when the class is loaded.

Local variables are declared within a method.

Instance variables are declared inside a class but not within a method.

Local variables do not get a default value. The compiler complains if you try to use a local variable before before the variable is initialised.

However, instance variables always get a default value. If you don't explicitly assign a value to an instance variable, the instance variable still has a value.

integers 0

floating points 0

Boolean false

references null

The main difference is instance variables get default values. Like an int value gets zero and a char gets a null, but not the local variables.

You can leave uninitialized instance variable, but where as local variables must be initialized otherwise you will get compiler error.

Existence time: I would like to tell you the major important difference between these variables is that when I encountered a problem where my instance variable during my software development worker life. Problem was occurring when user log in I have to return a username of user, who log in, but there is a problem, where for example one user log in it work successful but when another user log in while program run it return again a username, which log in before. I did run the program like debug mode and I could see a problem within my instance variable, which it could be local variable in my authentication method. The reason I tell that be careful when you work local and instance variable in programming language. All programmers don't take enough time simply topics, but small problems create great complexity.