Rule: Static vs. Non-static Method Scoping.
Static methods are scoped by class name; non-static methods are scoped by object name.
Section 8.1 Class vs. Instance
In a running Java program, there exists only one of any given class. But there might be as few as zero or many thousands of instances of the class (objects). It is important to understand the distinction between a class and an object.
We see this difference when invoking static and object (non-static) methods. Table 8.1.1 lists several examples.
| Static methods | Object methods |
|---|---|
Math.sqrt(…) |
rnd.nextDouble() |
String.valueOf(…) |
myString.toLowerCase() |
Arrays.sort(…) |
myArrayList.add(…) |
The left column of Table 8.1.1 lists several static method examples and the right column lists several object method examples. In previous chapters we have used all of these examples. Note that all examples in the left column require a class name to specify the scope in which the method resides. That is, only class names appear to the left of the dot-operator. By contrast, methods in the right column are scoped by object names, variables that reference an object. In other words, an object must be instantiated before any of these methods can be invoked. Stated differently, static methods are scoped by class; non-static methods are scoped by object.
The scoping distinction has ramifications on member access. Statements found within methods defined as
static may access only the statically-scoped members of the class. By contrast, statements found within methods defined without the static keyword have access both to non-static members declared within the object as well as the static members scoped by its class.This object scope, also know as instance scope, defines the fourth kind of Java scope that we have encountered. Anything defined within a class but not modified by the
static keyword exists in the scope an instance of the class, an object. See our list of Java scopes below.- package scope (limited to a Java package).
- class scope (accessible throughout the class), and
- object (instance) scope (limited to a specific object),
- method scope (limited to a specific method),
- block scope (limited to a specific block of code),
All of the methods that we’ve written in previous chapters were static (i.e. declared with class scope). This was set when we added the
static keyword modifier to a method declaration. By contrast, the object-scoped methods we used were defined in either Core Java libraries or other provided libraries, like those in DoodlePad. To take advantage of the object-oriented nature of Java we need to declare object-scoped fields that hold data specific to the instance and methods that have access to these fields. This enables us to define our own objects that encapsulate and manage data in accordance with the principles of object-oriented programming. Let’s learn how to define our own instantiatable classes that encapsulate object-specific data.
