difference between a class variable and local method variable with an example

can anyone help me in this regard.

when should we declare a variable local and when should we declare it as a class variable.

Originally posted by prasanna sheregar:
can anyone help me in this regard.

when should we declare a variable local and when should we declare it as a class variable.

class Student{
//Make the class variables private so no one can access them from outside
//Notice there are no corresponding setter methods provided.
//String (CLASS) variable to hold the students name
public String name;
//int (CLASS) variable to hold the students age
private int age;

/**
 * @param name The student name
 * @param age The student's age
 */
public Student(String name,int age) {
this.name=name;
this.age=age;
}
 
/**
 * Method to get the student's age
 * @return The student's age
 */
public int getAge() {
return age;
}
 
/**
 * Method to get the student's name
 * @return The student's name
 */
public String getName() {
return name;
}

/**
 * Method which will return the count of all students who are of the same age
 * as this one. Please ignore obvious flaws as this is just an example code.
 * @return The similar age student count
 */
public int getAgeGroupCount() {
//This integer will hold the count of all students which are of the
//same age as this student. This is a LOCAL variable. You cannot access the "count"
//from outside this method
int count=0;

//Some code here which will say look into the database or something
//and retrieve a list of all students
List<Student>studentList=......; //The DB call goes here which gives you the list
for(Student currentStudent:studentList) {
//Check the age of every student in the list.
//If it matches the age of this student, increment the count
if(currentStudent.getAge()==this.getAge())
count++;
}

return count;
}
}

Please read the code comments. They are self explanatory

The term "class variable" isn't a very clear way to describe a variable or field in Java.

I had assumed you meant a variable (better called a "field") associated with the class itself, not with an instance of the class. Such variables are declared "static". An unambiguous way to describe one of these is "a static field of a class".

But the above example has "instance fields" - variables that are associated with an instance of the class. Such variables do not have "static" in their declaration.

Originally posted by Peter Chase:

But the above example has "instance fields" - variables that are associated with an instance of the class. Such variables do not have "static" in their declaration.

Yup. But the whole point of the code snippet was to show the difference between the "count" (the local variable of the method) and the "age" the non-local (or class) variable.
[ August 30, 2007: Message edited by: Maneesh Godbole ]

The word to watch for when reading up on this kind of thing is "scope", that is how long does the variable live. A local variable exists only until the method returns. If you build up some temporary strings it's good to let them go out of scope when you return.

You can make an even shorter scope inside a pair of curly braces. If you declare a variable within a loop or if clause then it goes out of scope at the end brace.

If you build up a value that you'll need again later, losing it would be a bad thing. It would be better to make it a member field or static field. A member field scope matches the object instance; it's good until the object is no longer referenced. A static field scope is probably until you stop the JVM, though you could muck about with class loaders and get some sort of custom scope in controlled situations.
[ August 30, 2007: Message edited by: Stan James ]

class Example
{
int a ; //Instance Variable
void methodexample
{
int b ; // Local Variable
}
}

Hope this example is simple enough

i also know how to declare a class variable and local variable.

i want to know under what scenario we should declare a class variable and under what scenario we should declare a local variable?