View source for Chapter:Classes - Static members

= Classes: Static variables and methods=
So far, we have focused on instance variables, i.e. variables which every instance hold their own copy of. Now it's time to introduce variables that rather belong to the class itself and that every instance of the class "share". Such variables are called "class variables" or "static variables". The latter name comes from the fact that we use the modifier <code>static</code> when we declare such variables.

If you think about it, there are values which are not unique to every instance of a class, but rather shared. One example would be the interest rate of a bank account of some type. It is common that every bank account of the same type (e.g. a savings account) have the same interest rate. If every savings account have the same interest rate, say 0,01%, and if this interest rate would change for every bank account, should the bank decide to change it, then it is practical to have a mechanism for expressing that the variable holding the current interest rate is shared between all instances of the class SavingsAccount.

The modifier <code>static</code> has precisely this meaning when applied to a variable declared in the block of a class. An example with the interest rate could look something like:
<source lang="Java">
public class SavingsAccount{
  private static double interestRate = 0.01; // percent, shared by all instances
  // instance variable declarations like balance etc...
  // constructors...
  // methods...
}
</source>

An indication that a variable should be static is that the variable holds some value which is relevant to talk about without any relation to specific instances of the class. Another indication is that it is safe and natural that the variable has the same impact on every instance of a class, in the sense that if the variable's value changes, every instance will be effected by the change.

If you compare this to an instance variable such as the balance for an instance of SavingsAccount, you will see that the opposite holds for instance variables. It is not desirable that when one instance of a bank account changes the amount of the balance, every other instance of a bank account should also be affected. And it is not relevant to talk about the balance without the context of a particular instance of a bank account. The balance is the balance of one particular bank account! Therefore the balance is an instance variable which every bank account object will have its own copy of (so that they can have different balance). But the interest rate of some class of bank account, like a SavingsAccount, is relevant to talk about, even before any accounts have been created (the first customer enters the bank and decides she wants a savings account, because she agrees with the interest rate).

What about static methods, then (aka class methods)? Like with static variables, a static method is declared using the modifier <code>static</code>, and like static variables, static methods exist independent of any instances of the class it belongs to. Going back to the SavingsAccount class, there could be a static method for changing the static variable <code>interestRate</code>, something like this:
<source lang="Java">
public class SavingsAccount{
  private static double interestRate = 0.01; // percent
  public static void changeInterestRate(double newRate){
    // Some logic to check that it is a feasible value...
    interestRate = newRate;
  }
  // instance variables...
  // constructors...
  // instance methods...
}
</source>

Another potential case for static methods are convenience methods which only calculate something from its parameters, like the many static methods declared in <code>java.lang.Math</code>, for instance <code>public double sqrt(double d)</code> which calculate the square root of its parameter (given as argument in the calling code). Such a method only operates on its parameters and can therefore exist totally independent of any instances. In fact, you cannot create instances of the class Math!

So how do we call a public static method? We use the class name (where the method is declared) and a dot followed by the method and arguments:
<source lang="Java">
  /*
  
   |\
 A | \ C
   |__\
     B
  
  Calculate the length of C when we know the lengths of
  A (4)
  B (3)
  */
  double a = 4.0;
  double b = 3.0;
  double c = Math.sqrt(a*a+b*b); // Pythagoras...
</source>

A class method, or as it's also called, a static method, can only operate on static variables and its parameters. Why? Because we can call it regardless of any instances, even before any instances of the class is constructed. It is not possible to use instance variables inside a static method, because we don't know if there is any instances or which instance they would belong to. This is because we can call a static method via the class name so there is no reference to any specific instance known to the method.

While instance methods always have the keyword <code>this</code> as a reference to the instance for which the instance method was called, there is no such thing for a static method, since they are called using the class name.
==Chapters about classes==
Here are the chapters about classes in this book, so that you can keep a check on your progress:
* [[Chapter:Classes_-_Introduction]]
** [[Chapter:Classes_-_Introduction_-_Exercises]]
* [[Chapter:Classes_-_Declaration]]
** [[Chapter:Classes_-_Declaration_-_Exercises]]
* [[Chapter:Classes_-_Packages]]
** [[Chapter:Classes_-_Packages_-_Exercises]]
* [[Chapter:Classes_-_main]]
** [[Chapter:Classes_-_main_-_Exercises]]
* [[Chapter:Classes_-_Commenting_code]]
** [[Chapter:Classes_-_Commenting_code_-_Exercises]]
* [[Chapter:Classes_-_Declaring_variables]]
** [[Chapter:Classes_-_Declaring_variables_-_Exercises]]
* [[Chapter:Classes_-_Defining_constructors]]
** [[Chapter:Classes_-_Defining_constructors_-_Exercises]]
* [[Chapter:Classes_-_Defining_methods]]
** [[Chapter:Classes_-_Defining_methods_-_Exercises]]
* '''[[Chapter:Classes_-_Static_members]]''' « you are here!
** [[Chapter:Classes_-_Static_members_-_Exercises]]
* [[Chapter:Classes_-_final_members]]
** [[Chapter:Classes_-_final_members_-_Exercises]]
* [[Chapter:Classes_-_Using_packages]]
** [[Chapter:Classes_-_Using_packages_-_Exercises]]
* [[Chapter:Classes_-_Testing_your_classes]]
** [[Chapter:Classes_-_Testing_your_classes_-_Exercises]]
* [[Chapter:Classes_-_Using_your_classes]]
** [[Chapter:Classes_-_Using_your_classes_-_Exercises]]
* [[Chapter:Classes_-_API_source_code]]
** [[Chapter:Classes_-_API_source_code_-_Exercises]]
* [[Chapter:Classes_-_Other_keywords]]
** [[Chapter:Classes_-_Other_keywords_-_Exercises]]
* [[Chapter:Classes_-_Strings_are_immutable]]
** [[Chapter:Classes_-_Strings_are_immutable_-_Exercises]]

=Videos=
* Static variables [https://vimeo.com/183329185 (Eng)] [https://vimeo.com/183329247 (Swe)] [[:Media:Classes_III_Static_variables.pdf|Static variables (pdf)]]
* Static methods   [https://vimeo.com/183332858 (Eng)] [https://vimeo.com/183332870 (Swe)] [[:Media:Classes_III_Static_Methods.pdf|Static methods (pdf)]]

=Links=
==Further reading==
* [https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html Oracle tutorial - Class variables (static)]
* [https://docs.oracle.com/javase/tutorial/java/javaOO/classes.html Oracle's tutorial section on Classes]
* [https://en.wikipedia.org/wiki/Java_class_file Wikipedia on Java classes]

==Where to go next==
[[Chapter:Classes - Defining methods - Exercises|« Previous]] • [[Programming_with_Java#Chapters|Book TOC]] • [[Chapter:Classes_-_Static_members_-_Exercises|Next »]]
<!--
[[Programming_with_Java#Chapters|Book TOC]] | [[Chapter: Classes II|previous chapter]] | [[Chapter:Inheritance|next chapter]]
-->