I am summarizing static vs. non-static members of a class here.

A class in Java plays the following two key roles:

  1. Space for holding variables (static) that are used as global to
     the methods (both static methods and non-static methods) within
     the class.

  2. Blueprint for creating objects when we need to create objects 
     at run-time (dynamically), namely using 'new'.  It tells which
     state variables to include with what initial values.  Once a
     non-static (dynamic) object is created, each object contains its
     own state (consisting of the values of all of the non-static
     state variables in the class definition).  Also its own copy of
     each non-static method in the class.

     What about static variables and static methods?  There is only
     one copy of static object (referenced by the name same as the
     class name) created statically at compile-time.  The static
     variables and static methods are all shared by all of the dynamic
     objects that get created no matter how many you create.

If you have a class named Account, then a static object is created at
compile-time and is given the name same as the class name.  That is,
there is a static object that gets created with the name Account.  If
there is a static variable (field) named numAccounts in Account, you
can access it via Account.numAccounts.  Similarly, you can access any
static method using the same syntax, e.g., Account.getNumAccounts.  Of
course, we are assuming that the variable and the method are declared
public.  If any of them is declared to be private, then it would not
be allowed to be accessed at all from outside the class.  Of course
you can introduce accessor methods (getters and setters) in that case
and use them to access the private members indirectly.