Static fields and methods in Java are associated with the class rather than objects. A static field, like an int count, exists only once per class rather than being created separately for each object. All objects of a class share the same static field. A static block runs when the class is first loaded, before any objects are created. Static members can only access other static members—to access non-static fields or methods from a static context requires creating an object.

1. The story of Static keywords’ behavior in Java
Static is kind a opposite to Object Creation. Say you have a class person as
below:
class Person{
private int age;
// suppose it has getters and setters
}
Object of Person can be created in the main class like this:
Person p1 = new Person();
p1 is known as the object reference. The term hints on its bahaviour. It is a
pointer (a variable that can hold memory addresses) to a memory location where
object is situated. The memory where objects live is known as Heap. So object
reference point to a memory address on the heap which houses an int age field.
So in a way, you can say int age is the p1 object’s private data right?
Make sure you understand this.
Now lets suppose, it has another field say int count, forget about its purpose for
now!
So the new class would become:
class Person{
private int age;
static int count;
// suppose it has getters and setters for both
}
Notice it is static! What does that imply. As described in the lecture. Static
keyword changes the behavior of the field in focus i.e. int amount. It is no more
part of the object’s private data. It also implies it is not on the heap right?
As said during the lectures, it is actually associated with class. If you create
several object from the class Person say p1, p2, p3. All of these may have their
private data but do have the class Person in common. Static paves a way to
share data among these objects by associating it with the class. So static
features are associated with the class not with objects, memorize it now!
It can be accessed in the main method of the Main class like this. I am not writing
the whole main method’s signature for brevity.

2. //inside main
Person p1 = new Person();
p1.count; // what the hell!!!
you said its not part of the object’s private data. Well, its still not part of the
object’s private data and is not on the heap but java provides you with a way to
still access it through the object reference.
There is another way to access this, which is a better and more meaningful way
i.e. access it through the class name. So we access class Person’s amount field
like this:
// inside Main class’s main method
// i.e. outside the person class.
Person.amount;
As said earlier, all the object references p1, p2, p3 share a common class. The
quantity of a class is one. It means you create multiple objects from one class. It
also means class is written once for one or more objects to be created from it.
So if you create an amount field, it will also be one since it is associated with
class which is single (to be exact).
Suppose you have a Person as written in the second example (i.e. OO and static
fields) and you create three objects from it i.e. p1, p2, p3. How many
occurrences of age variable would be? And what is the count of the amount field
created in this scenario.
Ans: 3 objects so 3 occurrences of age fields inside each object.
and only occurrence of static field amount.
In addition to fields, you can also have static method. Its access is again similar
to the static field i.e. through class and object reference.
You can also have a static block as shown below:
class Person{
static{
sysout(“do whatever you like here”);
}
private int age;
static int amount;
Person(){}
// suppose it has getters and setters for both
}

3. Static block runs even before the constructor, normally used to load a native
routine in java. Or anything you wish to do once (as the class loads in JVM) even
before the constructor runs.
Another importance rule to mention here is static can only access another static
feature of the class e.g.
public class App {
int a;
public static void main( String[] args ){
System.out.println("trying to print a:"+a);
}
}
Error arises as below:
Cannot make a static reference to the non-static field a
Solution 1 to the above problem is through object creation as a is an OO field.
public class App {
int a;
public static void main( String[] args ){
App app = new App();
System.out.println("Access a like this:"+app.a);
}
}
Solution 2, make the field static as well
public class App {
static int a;
public static void main( String[] args ){
System.out.println("Access a by making it static inside
main method "
+ "which is also static:"+a);
}
}