Develop Reference

When do we use Class Variable, rather than using Object of class?

I am studying about static variables. They say that static variables are class variables.
They gave an example like this
class Bicycle{
private static int noOfBicycles = 0;
}
When calling this we can directly use the name of the class to call this variable without creating any object, i.e.
Bicycle.noOfBicycles
So when do we need these static variables rather than instance variables?

When a variable is declared as static, a single copy of the variable is created and shared among all objects at a class level. Static variables are, essentially, global variables. All instances of the class share the same static variable.
Instance variables are non-static variables and are declared in a class outside any method, constructor or block. As instance variables are declared in a class, these variables are created when an object of the class is created and destroyed when the object is destroyed.
The main differences between static and non static variables are
better explained here
Also already answered Static vs Instance Variables: Difference?

What does ObjectReference.VariableName mean?

I didn't understand this part:
Instance variables can be accessed directly by calling the variable name inside the class. However, within static methods (when instance variables are given accessibility), they should be called using the fully qualified name. ObjectReference.VariableName.
Can you give an example please ?

Static methods are methods that are called without a reference to an instance of that object. So instance variables cannot be called statically, as each instance will have its own values. So in a static method, you need a specific instance of an object in order to know which value of the instance variable you are trying to use.

The difference is how you access these variables:
class myClass {
public static int staticVar;
public int nonStaticVar;
//Constructor initialises both
}
Static approach:
int otherVariable = MyClass.staticVar;
As you can see, for the static variable you do not need to make an object to access it. Note that you can imagine a static variable to have the trait "once per class", which means, that you can not have 2 versions of staticVar.
Non Static (instance variable):
MyClass instanceOfMyClass = new myClass();
int otherVariable2 = instanceOfMyClass.nonStaticVar;
To have 2 versions of nonStaticVar you can simply make 2 objects and give this variable different values in the 2 objects. Note that in this case you have to make an object.

When to choose variables to declare as final static

I have used final and static variables as well. what i found about these variables is,
final variable
A final variable can only be initialized once, either via an initializer or an assignment statement.
Unlike the value of a constant, the value of a final variable is not necessarily known at compile time.
what variables should i declare as final-
Most often i use those variables whose value is constant universally and can never changed, such as the value of PI.
public static final double PI = 3.141592653589793;
static variables
These are those variables which belongs to the class and not to object(instance).
Static variables are initialized only once , at the start of the execution .
A single copy to be shared by all instances of the class
A static variable can be accessed directly by the class name and doesn’t need any object.
what variables should i declare as final-
Most of the time, i use those variables which i want to initialize only once and use them in the enitre class.
When to use final static variable
Now, i came across a term final static in one of my database project. I found that some of the database objects or even database version were declared as statci final.
static final String DATA_BASE = "BackUpDatabase.db";
static final int DATA_BASE_VERSION = 1;
Now, my question is what variables should we declare as final or static or final static, as using either of them could have solved the issue, then wyh to use both together.

static - Only use when a variable which is used globally
final - Only use when you need to declare a value as constant
static final - Only use when a value is globally used and it is a constant.
: - Here global means across all the instances of a java class

Variables declared as static final (or vice versa) are understood to be meaningful constants, and are named in all upper-case with underscores for spaces.
An example of a commonly encountered constant is Integer.MAX_VALUE, or Math.PI.

final only says that value once initialized can't be changed; static says that the attribute belongs to Class and NOT objects.
So when you say final static; this means there is just one copy of variable and it can't be changed.

- static in java means Class's member. Its shared by all the instances of the class.
- final keyword in java means, constant, but has different interpretation depending on what its being applied.
- When we use static final on a field, consider it as a Global variable.
- PI is static variable of Math Class and its directly accessed using the class name, as Math.PI.
- Use all letters in caps to define a static final variable.
final's interpretation:
final variable : Its value canNot be changed
final method : It canNot be overridden
final class : It canNot be extended
final Parameter : Its value canNot be changed which it receives from caller's argument
final Object Reference Variable : It canNot refer to any other object, other than the one its currently referring to

Declaring variables only as static can lead to change in their values by one or more instances of a class in which it is declared.
Declaring them as static final will help you to create a CONSTANT as #Vulcan told. Only one copy exists which can be accessed anywhere.

Static Variable
You can change the static variable value by calling static method
present in same class .
Static variable value will be same for all object created from this
class . if we change the value then all object of that class will get
new value ,old value will be lost.
Value can be changed multiple times.
Final variable
This variable value can be initialized by two way:
At the time of declaring the variable.
At the time of creating object of that class where class constructor will have this.finalvariable = newfinalvariablevalue;
Once initialized it can't be changed by any method (Static or non-static).

static methods or classes are implicitly final .
Because there is only one copy of this method existing for all the objects which means that subclasses dont have access to modify the copy.
lets say you have a method in the parent and you dont want subclasses to change this method.. just declare the parent method as a final. Here you go.
class Parent {
final void myMethod() {
//No one can change this method from subclassess
//compiler works efficiently because it knows that this method will not change
}
}
class Child extends Parent{
//from this class I can use myMethod but I cannot override.
}

Is a final variable instantiated everytime

When we have a final instance variable of a class, is it instantiated for each object created of the class or just created once and referred?
And what is the case if the final variable is a local class variable??

The final modifier simply indicates that the variable can be assigned once and never again. It has no impact on the instantiation; the rules are the same as for normal variables. All the final modifier does is prevent the value being assigned a second time.
Examples below.
private final List myList = new ArrayList();
The list will be instantiated each time this is run, i.e. each time the enclosing class is instantiated.
public void bob() {
final List myList = new ArrayList();
}
The list will be instantiated each time this is run, i.e. each time the method bob is invoked.
private static final List MY_LIST = new ArrayList();
Again, the list will be instantiated each time this is run. As this is also a static field initializer, this code will be run when the class is first loaded. So, for simplistic programs, this will be run once -- in scenarios where multiple class loaders are in play (e.g. app-servers etc), however, this will be run once each time the class is loaded in a new class loader.

Final variables is instantiated for each instance of the class. The values once assigned to them may not be changed. These variables may be initialized once, either via an initializer or an assignment statement.
What you are referring to are the static variables. These variable is not attached to a particular object, but rather to the class as a whole. They are allocated when the class is loaded.
Taking these two together, you can have a static final variable for the class. This basically means that the value assigned to the variable once assigned is constant and that it would be attached to a class rather than an instance of the class.

Instance variables, class variables, and local variables are used to refer to three different things, so calling a variable an "instance variable of a class," or "local class variable" is confusing.
An instance variable belongs to an object. Whether it's final or not, space is allocated in every instance for it. If it's final, a value must be assigned during construction, and the variable can be assigned only once.
A class variable belongs to the class as a whole. There's only one variable, regardless of the number of objects of that class, and all instances can refer to it. Declaring a variable as static means that it belongs to the class. Like instance variables, a static class variable can be declared final. Then it must be assigned a value once and only once when the class is initialized.
A local variable is declared within a method, and the variable occupies space in the method stack frame—although that variable may hold a pointer to an object in the heap. Local variables can be final, which means they can be assigned only once. Also, if a local variable is final, it can be referenced by inner classes instantiated in the method.

Variables are not the ones that are instantiated. Classes are instantiated. Variables are initialized. Instance variables must be initialized by the time the the object is constructed and if they are final you won't be able to reassign values to them. If it's an instance variable then each instance of the class will have it's own copy, otherwise if it's static then there will be only one copy which will belong to the class itself.

When will I use a Class Variable in Java v.s an Instance Variable?

Here is a generic class that I have defined, what I would like to know is when I am creating more specific classes for instance a CAR class when would I use a Class Variable? My personal understanding of a class variable is that a single copy of a class variable that has been declared in a class will be declared using the keyword static, and that each object that has been instantiated from the class will contain a single copy of the class variable.
An instance variable allows each instance of a class / object that has been created from the class to have a separate copy of the instance variable per object?
So an instance variable is useful for defining the properties of a class / data-type e.g a House would have a location, but now when would I use a class variable in a House object? or in other words what is the correct use of a class object in designing a class?
public class InstanceVaribale {
public int id; //Instance Variable: each object of this class will have a seperate copy of this variable that will exist during the life cycle of the object.
static int count = 0; //Class Variable: each object of this class will contain a single copy of this variable which has the same value unless mutated during the lifecycle of the objects.
InstanceVaribale() {
count++;
}
public static void main(String[] args) {
InstanceVaribale A = new InstanceVaribale();
System.out.println(A.count);
InstanceVaribale B = new InstanceVaribale();
System.out.println(B.count);
System.out.println(A.id);
System.out.println(A.count);
System.out.println(B.id);
System.out.println(B.count);
InstanceVaribale C = new InstanceVaribale();
System.out.println(C.count);
}
}

My personal understanding of a class variable is that a single copy of a class variable that has been declared in a class will be declared using the keyword static, and that each object that has been instantiated from the class will contain a single copy of the class variable.
No. It's not that "each object will contain a single copy". A static variable is associated with the type rather than each instance of the type. The instances don't have the variable at all.
There's exactly one variable (assuming you're only loading it from one classloader) however many instances of the type there are. No instances? Still one variable. A million instances? Still one variable.
Static variables are mostly useful for constants or constant-alikes - things like loggers, or "the set of valid prices" etc. Things which don't change over the course of the application. They should almost always be final in my experience, and the type should be an immutable type (like String). Where possible, use immutable collections too for static variables - or make sure the variable is private and that you never mutate the collection within the class.
You should avoid using static variables to store global changing state. It makes code much harder to test and reason about.

Static variables are used to store values that are shared between all instances of the class.
If this is not the case, it should be an instance variable.

1. Every object of the class will have its own copy of Instance Variable,its One per Object.
2. But static variable will be shared by all the objects of the class, its One per Class.
3. Now i will give 2 example where these two will have importance.
Instance variable:
Consider a Gaming Program, then each player will have different Name, Scores, Weapons-power, Stage reached, etc.....
Static variable:
Consider a Banking program, where each client will be given an Id, which is greater and unique than the previous one, so static variable will be apt for this.