No difference at all. According to 8.3.1 - Classes - Field Modifiers of the Java Language Specification,
If two or more (distinct) field modifiers appear in a field declaration, it is customary, though not required, that they appear in the order consistent with that shown above in the production for FieldModifier.
For fields, the said production lists the modifiers in this order:
@Annotationpublicprotectedprivatestaticfinaltransientvolatile
And for methods:
Answer from Gergely Szilagyi on Stack Overflow
@Annotationpublicprotectedprivateabstractstaticfinalsynchronizednativestrictfp
No difference at all. According to 8.3.1 - Classes - Field Modifiers of the Java Language Specification,
If two or more (distinct) field modifiers appear in a field declaration, it is customary, though not required, that they appear in the order consistent with that shown above in the production for FieldModifier.
For fields, the said production lists the modifiers in this order:
@Annotationpublicprotectedprivatestaticfinaltransientvolatile
And for methods:
@Annotationpublicprotectedprivateabstractstaticfinalsynchronizednativestrictfp
They are the same. The order of modifiers is not significant. And note that the same rule applies in all contexts where modifiers are used in Java.
However, most Java style guides recommend/mandate the same specific order for the modifiers. In this case, it is public static final.
Videos
Can a final variable be static in Java?
What are the best practices for using final and static in Java?
How do final and static affect inheritance in Java?
final - The value assigned to the variable cannot be changed.
static - Even in different class instances, compiler will allocate the same memory location to the variable which it had assigned no matter how many instances of that class. The value can be changed.
My question is: Why is the final keyword not allocating the same memory location to the variable, if the value cannot change?
Let us have different instances of a class and still we will have the same value in the variable as it has been declared as final.
Why do we need to write static final then, it could have been done via final only, am I missing on thinking some cases?
If someone can please clarify?
I just had a codereview in which I thought the reviewer was not constructive/particularly helpful. One of the things he was worried about was that I'd declared variables as final static, and not as static final.
I've looked around on google but I cannot find what the difference between these two would be (except for naming conventions).
The thing is, I labelled them final static because I had originally set the as just static, but then my IDE (IntelliJ) suggested they could be final as well. So I let the IDE do the replacement, and it made them final static.
His IDE marked it as wrong (mine didn't), and that was the main reason he gave. I think he also said something about naming conventions but we were out of time so I couldn't ask him to explain what was wrong with final static.
Was my reviewer in the right? Is there a difference between final static and static final outside of naming conventions?
But even if i declare a variable only final, then it remains the same for all the objects as i need to initialize them in the program itself and not at the run time.
No, non-static final members can be initialized in the constructor. They cannot be re-assigned after that.
The final means you can assign only one time the value to the variable. The final can be use in many scopes and is very useful, in a object property you must (and forced) to set the value on the declaration, or in the constructor or in the initialization block of the object.
And the static is to set the scope of the variable, that means in a class property that value is storage inside the class, and can be access even without an object, when you use static final or final static you must (and forced) to set the value on the declaration or inside a static initialization code of the class.
Example:
public class NewClass {
static final int sc = 123; //I recommend to use this declaration style.
final static int scc;
final int o = 123;
final int oo;
final int ooo;
static {
scc = 123;
}
{
oo = 123;
}
public NewClass() {
ooo = 123;
}
void method(final int p) {
// p=123; //Error, the value is only assigned at the call of the method.
final int m = 123;
final int mm;
mm = 123;
// mm = 456; //Error, you can set the value only once.
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(m + p); //You still can reach the variables.
}
}).start();
}
}
The static keyword can be used in 4 scenarios
- static variables
- static methods
- static blocks of code
- static nested class
Let's look at static variables and static methods first.
Static variable
- It is a variable which belongs to the class and not to object (instance).
- Static variables are initialized only once, at the start of the execution. These variables will be initialized first, before the initialization of any instance variables.
- 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.
- Syntax:
Class.variable
Static method
- It is a method which belongs to the class and not to the object (instance).
- A static method can access only static data. It can not access non-static data (instance variables) unless it has/creates an instance of the class.
- A static method can call only other static methods and can not call a non-static method from it unless it has/creates an instance of the class.
- A static method can be accessed directly by the class name and doesn’t need any object.
- Syntax:
Class.methodName() - A static method cannot refer to
thisorsuperkeywords in anyway.
Static class
Java also has "static nested classes". A static nested class is just one which doesn't implicitly have a reference to an instance of the outer class.
Static nested classes can have instance methods and static methods.
There's no such thing as a top-level static class in Java.
Side note:
main method is
staticsince it must be be accessible for an application to run before any instantiation takes place.
final keyword is used in several different contexts to define an entity which cannot later be changed.
A
finalclass cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the Java standard library classes arefinal, for examplejava.lang.Systemandjava.lang.String. All methods in afinalclass are implicitlyfinal.A
finalmethod can't be overridden by subclasses. This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.A
finalvariable can only be initialized once, either via an initializer or an assignment statement.
It does not need to be initialized at the point of declaration, this is called ablank finalvariable, but in this case:- A
blank finalinstance variable must be assigned at every constructor of its class. - A
blank finalstatic variable must be assigned in a static initializer in its class.
- A
Note: If the variable is a reference, this means that the variable cannot be re-bound to reference another object. But the object that it references is still mutable, if it was originally mutable.
When an anonymous inner class is defined within the body of a method, all variables declared final in the scope of that method are accessible from within the inner class. Once it has been assigned, the value of the final variable cannot change.
static means it belongs to the class not an instance, this means that there is only one copy of that variable/method shared between all instances of a particular Class.
public class MyClass {
public static int myVariable = 0;
}
//Now in some other code creating two instances of MyClass
//and altering the variable will affect all instances
MyClass instance1 = new MyClass();
MyClass instance2 = new MyClass();
MyClass.myVariable = 5; //This change is reflected in both instances
final is entirely unrelated, it is a way of defining a once only initialization. You can either initialize when defining the variable or within the constructor, nowhere else.
note A note on final methods and final classes, this is a way of explicitly stating that the method or class can not be overridden / extended respectively.
Extra Reading So on the topic of static, we were talking about the other uses it may have, it is sometimes used in static blocks. When using static variables it is sometimes necessary to set these variables up before using the class, but unfortunately you do not get a constructor. This is where the static keyword comes in.
public class MyClass {
public static List<String> cars = new ArrayList<String>();
static {
cars.add("Ferrari");
cars.add("Scoda");
}
}
public class TestClass {
public static void main(String args[]) {
System.out.println(MyClass.cars.get(0)); //This will print Ferrari
}
}
You must not get this confused with instance initializer blocks which are called before the constructor per instance.