Difference between Static and final?

java

Solution

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 `this` or `super` keywords 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 `static` since 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 `final` class cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the Java standard library classes are `final`, for example `java.lang.System` and `java.lang.String`. All methods in a `final` class are implicitly `final`.

A `final` method 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 `final` variable 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 a `blank final` variable, but in this case:

- A `blank final` instance variable must be assigned at every constructor of its class.

- A `blank final` static variable must be assigned in a static initializer in its class.

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.

Problem

Original source