The variable is the basic unit of storage in a Java program. A variable is defined by the combination of an identifier, a type, and an optional initializer. In addition, all variables have a scope, which defines their visibility, and a lifetime. These elements are examined next.<\/p>\n
In Java, all variables must be declared before they can be used. The basic form of a variable declaration is shown here:<\/p>\n
\n
\ntype identifier [ = value][, identifier [= value] …] ;<\/i><\/p>\n<\/blockquote>\n\n
- The type is one of Java\u2019s atomic types (Data Types), or the name of a class or interface. (We will discussed about Class and interface types later ).<\/li>\n
- The identifier is the name of the variable.<\/li>\n
- You can initialize the variable by specifying an equal sign and a value. Keep in mind that the initialization expression must result in a value of the same (or compatible) type as that specified for the variable.<\/li>\n
- To declare more than one variable of the specified type, use a comma separated list.<\/li>\n<\/ul>\n
Example<\/h3>\n
\n
\nint a, b, c; \/\/ declares three ints, a, b, and c.<\/i><\/p>\nint d = 3, e, f = 5; \/\/ declares three more ints, initializing \/\/ d and f.<\/p>\n
byte z = 22; \/\/ initializes z.<\/p>\n
double pi = 3.14159; \/\/ declares an approximation of pi.<\/p>\n
char x = ‘x’; \/\/ the variable x has the value ‘x’.<\/p>\n
boolean d = false;\u00a0 \u00a0\/\/ boolean value initialized with value false;<\/p>\n<\/blockquote>\n
The identifiers that you choose have nothing intrinsic in their names that indicates their<\/p>\n
type.<\/p>\n
Dynamic Initialization<\/h3>\n
Although the preceding examples have used only constants as initializers, Java allows variables to be initialized dynamically, using any expression valid at the time the variable is declared. Example Program for Dynamic variable Initialization:<\/p>\n
class DynInit {\r\npublic static void main(String args[]) {\r\ndouble a = 3.0, b = 4.0;\r\n\/\/ c is dynamically initialized\r\ndouble c = Math.sqrt(a * a + b * b);\r\nSystem.out.println(\"Hypotenuse is \" + c);\r\n}\r\n}<\/pre>\n\n
- Here, three local variables\u2014a, b, and c\u2014are declared. The first two, a and b, are initialized by constants.<\/li>\n
- c is initialized dynamically to the length of the hypotenuse.<\/li>\n
- The program uses another of Java\u2019s built-in methods, sqrt( ), which is a member of the Math class, to compute the square root of its argument.<\/li>\n
- The key point here is that the initialization expression may use any element valid at the time of the initialization, including calls to methods, other variables, or literals.<\/li>\n<\/ul>\n
The Scope and Lifetime of Variables<\/h3>\n
So far, all of the variables used have been declared at the start of the main( ) method. However, Java allows variables to be declared within any block. A block defines a scope. Thus, each time you start a new block, you are creating a new scope. A scope determines what objects are visible to other parts of your program. It also determines the lifetime of those objects.
<\/div> <\/div><\/p>\nThere are three kinds of variables in Java based on scope & lifetime<\/b><\/p>\n
Local Variable\u00a0:<\/b> Local variables are declared in methods, constructors, or blocks.<\/p>\n
Global Variable\/Instance Variable\u00a0: <\/b>Instance variables are declared in a class, but outside a method, constructor or any block.<\/p>\n
Instance variable are also variable of object commonly known as field or property. They are referred as object variable. Each object has its own copy of each variable and thus, it doesn’t effect the instance variable if one object changes the value of the variable.<\/p>\n
class Student\r\n{\r\n String name;\r\n int age;\r\n}<\/pre>\nHere\u00a0name<\/b> and\u00a0age<\/b> are instance variable of Student class.<\/p>\n
Class\/Static Variables : <\/b>Class variables also known as static variables are declared with the static keyword in a class. Static variables are also used in declaring constant along with final keyword. we will see about static variable in detail in upcoming chapters<\/p>\n
class Student\r\n{\r\n String name;\r\n int age;\r\n static int collegeCode =1101;\r\n}<\/pre>\nHere\u00a0collegeCode<\/b>\u00a0is a static variable. Each object of Student class will share\u00a0collegeCode<\/b>\u00a0property.<\/p>\n
Scope of the varialbe with example Program<\/p>\n
\/\/ Demonstrate block scope.\r\nclass Scope {\r\npublic static void main(String args[]) {\r\nint x; \/\/ known to all code within main\r\nx = 10;\r\nif(x == 10) { \/\/ start new scope\r\nint y = 20; \/\/ known only to this block\r\n\/\/ x and y both known here.\r\nSystem.out.println(\"x and y: \" + x + \" \" + y);\r\nx = y * 2;\r\n}\r\n\/\/ y = 100; \/\/ Error! y not known here\r\n\/\/ x is still known here.\r\nSystem.out.println(\"x is \" + x);\r\n}\r\n}<\/pre>\nWithin a block, variables can be declared at any point, but are valid only after they are declared. If you define a variable at the start of a method, it is available to all of the code within that method.<\/p>\n
\n
- Variables are created when their scope is entered, and destroyed when their scope is left.<\/li>\n
- Variable will not hold its value once it has gone out of scope.<\/li>\n
- Variables declared within a method will not hold their values between calls to that method. Also, a variable declared within a block will lose its value when the block is left. Thus, the lifetime of a variable is confined to its scope.<\/li>\n
- If a variable declaration includes an initializer, then that variable will be reinitialized each<\/li>\n
- time the block in which it is declared is entered.<\/li>\n<\/ul>\n
\/\/ Demonstrate lifetime of a variable.\r\nclass LifeTime {\r\npublic static void main(String args[]) {\r\nint x;\r\nfor(x = 0; x < 3; x++) {\r\nint y = -1; \/\/ y is initialized each time block is entered\r\nSystem.out.println(\"y is: \" + y); \/\/ this always prints -1\r\ny = 100;\r\nSystem.out.println(\"y is now: \" + y);\r\n}\r\n}\r\n}<\/pre>\nOutput<\/b><\/p>\n
y is: -1\r\ny is now: 100\r\ny is: -1\r\ny is now: 100\r\ny is: -1\r\ny is now: 100<\/pre>\nDuplicate Variable\u00a0 Error<\/h3>\n
Although blocks can be nested, you cannot declare a variable to have the same name as one in an outer scope. For example, the following program is illegal:<\/p>\n
\/\/ This program will not compile\r\nclass ScopeErr {\r\npublic static void main(String args[]) {\r\nint bar = 1;\r\n{ \/\/ creates a new scope\r\nint bar = 2; \/\/ Compile-time error \u2013 bar already defined!\r\n}\r\n}\r\n}<\/pre>\n\n