TABLE 6 . 1 :
Access matrix for static / instance for methods.
( Has access to )
( Static method ) Instance method )
Static variables and methods
Instance variables and methods
System. out . println (Die . getRandomDieValue () ) ;
Good software practices call for static method to be invoked on classes and not
objects. Invoking a static method on an object gives the false illusion to the human
reader of the code that the method is instance.
The new version of the Die class demonstrates data encapsulation . This means that the
data is only accessible from within the class in which it is defined and therefore we do
not need to worry that someone from outside the class can assign an incorrect value to an
instance variable. Note that the reason that the variable dieValue cannot be accessed from
outside the class is because it is defined as a private variable. If the variable dieValue
were defined as a public variable, then the following code will be valid.
Die d = new Die () ;
d. dieValue = − 4;
However, this code allows direct access to the instance variables of the class and therefore
makesthemethodsinthe Die class obsolete. This is the reason why all variables will be
declared as private throughout the topic. The only exception is constants (i.e., static
final variables). They can be declared as public because nobody can change their value.
The getRandomDieValue method is defined as private becausewedesirethatitonly
be called from within the Die class. In general, methods that are part of the interface of the
class (i.e., can be called by the outside world) will be defined as public . Utility methods that
are only needed within the class should be defined as private .The getRandomDieValue
method is defined as static because it is not related to a particular instance of the class
and does not access the instance variable dieValue .
Data abstraction is another important feature of the object-oriented paradigm. Data
abstraction means that the details of how the data is physically stored are abstracted. For
example, someone may decide to store the variable dieValue in a byte instead of an int .
However, the interface of the class (i.e., its public methods) does not need to change and
therefore all the methods that interact with the Die class will remain the same. In other
words, we can make changes to the class that will not affect how the outside world interacts
with the class. Similarly, changes to the outside world will not affect the behavior of the
We can think of a class as being its own silo that contains private variables and
public interface to these variables. The code inside a class should be self-contained.
Changing it should not affect code outside the class. Similarly, changing code outside
the class should not affect the code in the class. Unless there is a good reason not to
do so, all the variables inside a class should be defined as private .
Consider Table 6.1. It is a matrix that tells us which methods have access to which data
and methods inside a class. For example, a static method has no direct access to instance
methods and variables because there is no current instance of the class. For example, since