Working with Objects
This chapter is from the book
This chapter is from the book
This chapter is from the book
Java is a heavily object-oriented programming language. When you do work in Java, you use objects to get the job done. You create objects, modify them, move them around, change their variables, call their methods, and combine them with other objects. You develop classes, create objects out of those classes, and use them with other classes and objects.
Today you will work extensively with objects. The following topics are covered:
Creating objects (also called instances)
Testing and modifying class and instance variables in those objects
Calling an object's methods
Converting objects and other types of data from one class to another
Creating New Objects
When you write a Java program, you define a set of classes. As you learned during Day 1, "Getting Started with Java," classes are templates that are used to create objects. These objects, which are also called instances, are self-contained elements of a program with related features and data. For the most part, you use the class merely to create instances and then work with those instances. In this section, therefore, you will learn how to create a new object from any given class.
Remember strings from yesterday? You learned that using a string literal (a series of characters enclosed in double quotation marks) creates a new instance of the class String with the value of that string.
The String class is unusual in that respect. Although it's a class, there's an easy way to create instances of that class using a literal. To create instances of other classes, the new operator is used.
NOTE
What about the literals for numbers and characters—don't they create objects, too? Actually, they don't. The primitive data types for numbers and characters create numbers and characters, but for efficiency they actually aren't objects. You can put object wrappers around them, though, if you need to treat them like objects (which you learn to do on Day 5, "Creating Classes and Methods").
Using new
To create a new object, you use the new operator with the name of the class you want to create an instance of, followed by parentheses:
String name = new String();
URL address = new URL("http://www.java21days.com");
VolcanoRobot robbie = new VolcanoRobot();
The parentheses are important; don't leave them off. The parentheses can be empty, in which case the most simple, basic object is created, or the parentheses can contain arguments that determine the initial values of instance variables or other initial qualities of that object.
The following examples show objects being created with arguments:
Random seed = new Random(6068430714); Point pt = new Point(0,0);
The number and type of arguments you can use inside the parentheses with new are defined by the class itself using a special method called a constructor. (You'll learn more about constructors later today.) If you try to create a new instance of a class with the wrong number or type of arguments (or if you give it no arguments and it needs some), you get an error when you try to compile your Java program.
Here's an example of creating different types of objects with different numbers and types of arguments: the StringTokenizer class, part of the java.util package, divides a string into a series of shorter strings called tokens.
A string is divided into tokens by applying some kind of character or characters as a delimiter. For example, the text "02/20/67" could be divided into three tokens—02, 20, and 67—using the slash character ("/") as a delimiter.
Listing 3.1 is a Java program that creates StringTokenizer objects by using new in two different ways and then displays each token the objects contain.
LISTING 3.1 The Full Text of ShowTokens.java
1: import java.util.StringTokenizer;
2:
3: class ShowTokens {
4:
5: public static void main(String[] arguments) {
6: StringTokenizer st1, st2;
7:
8: String quote1 = "VIZY 3 -1/16";
9: st1 = new StringTokenizer(quote1);
10: System.out.println("Token 1: " + st1.nextToken());
11: System.out.println("Token 2: " + st1.nextToken());
12: System.out.println("Token 3: " + st1.nextToken());
13:
14: String quote2 = "NPLI@9 27/32@3/32";
15: st2 = new StringTokenizer(quote2, "@");
16: System.out.println("\nToken 1: " + st2.nextToken());
17: System.out.println("Token 2: " + st2.nextToken());
18: System.out.println("Token 3: " + st2.nextToken());
19: }
20: }
When you compile and run the program, the output should resemble the following:
Token 1: VIZY Token 2: 3 Token 3: -1/16 Token 1: NPLI Token 2: 9 27/32 Token 3: 3/32
In this example, two different StringTokenizer objects are created using different arguments to the constructor listed after new.
The first instance (line 9) uses new StringTokenizer() with one argument, a String object named quote1. This creates a StringTokenizer object that uses the default delimiters: blank spaces, tab, newline, carriage return, or formfeed characters.
If any of these characters is contained in the string, it is used to divide the tokens. Because the quote1 string contains spaces, these are used as delimiters dividing each token. Lines 10–12 display the values of all three tokens: VIZY, 3, and -1/16.
The second StringTokenizer object in this example has two arguments when it is constructed in line 14—a String object named quote2 and an at-sign character ("@"). This second argument indicates that the "@" character should be used as the delimiter between tokens. The StringTokenizer object created in line 15 contains three tokens: NPLI, 9 27/32, and 3/32.
What new Does
Several things happen when you use the new operator—the new instance of the given class is created, memory is allocated for it, and a special method defined in the given class is called. This special method is called a constructor.
A constructor is a special method for creating and initializing a new instance of a class. A constructor initializes the new object and its variables, creates any other objects that the object needs, and performs any other operations that the object needs to initialize itself.
Multiple constructor definitions in a class can each have a different number, or type, of arguments. When you use new, you can specify different arguments in the argument list, and the correct constructor for those arguments will be called. Multiple constructor definitions are what enabled the ShowTokens() class in the previous example to accomplish different things with the different uses of the new operator. When you create your own classes, you can define as many constructors as you need to implement the behavior of the class.
A Note on Memory Management
If you are familiar with other object-oriented programming languages, you might wonder whether the new statement has an opposite that destroys an object when it is no longer needed.
Memory management in Java is dynamic and automatic. When you create a new object, Java automatically allocates the right amount of memory for that object. You don't have to allocate any memory for objects explicitly. Java does it for you.
Because Java memory management is automatic, you do not need to de-allocate the memory an object uses when you're done using the object. Under most circumstances, when you are finished with an object you have created, Java will be able to determine that the object no longer has any live references to it. (In other words, the object won't be assigned to any variables still in use or stored in any arrays.)
As a program runs, Java periodically looks for unused objects and reclaims the memory that those objects are using. This process is called garbage collection, and it's entirely automatic. You don't have to explicitly free the memory taken up by an object; you just have to make sure you're not still holding onto an object you want to get rid of.