- Creating New Objects
- Using Class and Instance Variables
- Calling Methods
- References to Objects
- Casting Objects and Primitive Types
- Comparing Object Values and Classes
- Summary
- Q&A
- Quiz
- Certification Practice
- Exercises
This chapter is from the book
This chapter is from the book
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 defined in it, 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 use 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 local 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 local variable.
Setting Values
Assigning a value to an instance variable with dot notation employs the = operator just like local variables:
customer.layaway = true;
This example sets the value of a boolean instance variable named layaway to true.
The PointSetter application shown in isting 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 then type the source code shown in Listing 3.2 and save the file.
Listing 3.2. The Full Text of PointSetter.java
1: import java.awt.Point;
2:
3: class PointSetter {
4:
5: public static void main(String[] arguments) {
6: Point location = new Point(4, 13);
7:
8: System.out.println("Starting location:");
9: System.out.println("X equals " + location.x);
10: System.out.println("Y equals " + location.y);
11:
12: System.out.println("\nMoving to (7, 6)");
13: location.x = 7;
14: location.y = 6;
15:
16: System.out.println("\nEnding location:");
17: System.out.println("X equals " + location.x);
18: System.out.println("Y equals " + location.y);
19: }
20: }
When you run this application, the output is the following:
Output ▾
Starting location: X equals 4 Y equals 13 Moving to (7, 6) Ending location: X equals 7 Y equals 6
In this application, you first create an instance of Point where x equals 4 and y equals 13 (line 6). These individual values are retrieved using dot notation.
The value of x is changed to 7 and y to 6. Finally, 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.
For this reason, it’s a good idea to use the name of the class when you refer to a class variable. It makes your code easier to read and makes strange results easier to debug.