Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book

Using Class and Instance Variables

At this point, you can create your own object with class and instance variables, but how do you work with those variables? They’re used in largely the same manner as the local variables you learned about yesterday. You can put them in expressions, assign values to them in statements, and so on. You just refer to them slightly differently.

Getting Values

To get to the value of an instance variable, you use dot notation, a form of addressing in which an instance or class variable name has two parts:

  • A reference to an object or class on the left side of a dot operator.
  • A variable on the right side

Dot notation is how you refer to an object’s instance variables and methods.

For example, if you have an object named customer with a variable called orderTotal, here’s how that variable could be referred to in a statement:

float total = customer.orderTotal;

This statement assigns the value of the customer object’s orderTotal instance variable to a floating-point variable named total.

Accessing variables in dot notation is an expression (meaning that it returns a value). Both sides of the dot also are expressions. This means that you can chain instance variable access.

Extending the preceding example, suppose the customer object is an instance variable of the store class. Dot notation can be used twice, as in this statement:

float total = store.customer.orderTotal;

Dot expressions are evaluated from left to right, so you start with store’s instance variable customer, which itself has an instance variable orderTotal. The value of this variable is assigned to the total variable.

One thing to note when chaining objects together in this manner is that the statement will fail with an error if any object in the chain does not have a value yet.

Setting Values

Assigning a value to an instance variable with dot notation employs the = operator just like variables holding primitive types:

customer.layaway = true;

This example sets the value of a boolean instance variable named layaway to true.

The PointSetter application in Listing 3.2 tests and modifies the instance variables in a Point object. Point, a class in the java.awt package, represents points in a coordinate system with (x, y) values.

Create a new empty Java file in NetBeans with the class name PointSetter and the package name com.java21days; then type the source code shown in Listing 3.2 and save the file.

LISTING 3.2 The Full Text of PointSetter.java

 1: package com.java21days;
 2:
 3: import java.awt.Point;
 4:
 5: class PointSetter {
 6:
 7:     public static void main(String[] arguments) {
 8:         Point location = new Point(4, 13);
 9:
10:         System.out.println("Starting location:");
11:         System.out.println("X equals " + location.x);
12:         System.out.println("Y equals " + location.y);
13:
14:         System.out.println("\nMoving to (7, 6)");
15:         location.x = 7;
16:         location.y = 6;
17:
18:         System.out.println("\nEnding location:");
19:         System.out.println("X equals " + location.x);
20:         System.out.println("Y equals " + location.y);
21:     }
22: }

When you run this application, the output should match Figure 3.2.

FIGURE 3.2

FIGURE 3.2 Setting and displaying an object’s instance variables.

In this application, you create an instance of Point where x equals 4 and y equals 13 (line 8). These individual values are retrieved using dot notation.

The value of x is changed to 7 and y to 6 (lines 15–16). The values are displayed again to show how they have changed.

Class Variables

Class variables, as you have learned, are variables defined and stored in the class itself. Their values apply to the class and all its instances.

With instance variables, each new instance of the class gets a new copy of the instance variables that the class defines. Each instance then can change the values of those instance variables without affecting any other instances. With class variables, only one copy of that variable exists when the class is loaded. Changing the value of that variable changes it for all instances of that class.

You define class variables by including the static keyword before the variable itself. For example, consider the following partial class definition:

class FamilyMember {
    static String surname = "Mendoza";
    String name;
    int age;
}

Each instance of the class FamilyMember has its own values for name and age, but the class variable surname has only one value for all family members: “Mendoza.” If the value of surname is changed, all instances of FamilyMember are affected.

To access class variables, you use the same dot notation as with instance variables. To retrieve or change the value of the class variable, you can use either the instance or the name of the class on the left side of the dot operator. Both lines of output in this example display the same value:

FamilyMember dad = new FamilyMember();
System.out.println("Family's surname is: " + dad.surname);
System.out.println("Family's surname is: " + FamilyMember.surname);

Because you can use an object to change the value of a class variable, it’s easy to become confused about class variables and where their values are coming from. Remember that the value of a class variable affects all objects of that particular class. If the surname instance variable of one FamilyMember object was set to “Paciorek”, all objects of that class would have that new surname.

To reduce confusion when using class variables, it’s a good idea to use the name of the class when you refer to a class variable—not an object of that class. This makes the use of a class variable more clear and helps strange results become easier to debug.

  • + Share This
  • 🔖 Save To Your Account