Working with Objects in Java
Java is an object-oriented programming language. When you do work in Java, you primarily use objects to get the job done. You create objects, modify them, 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 work extensively with objects as you undertake these essential tasks:
- Creating objects
- Testing and modifying their class and instance variables
- Calling an object’s methods
- Converting objects 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,” a class is a template used to create one or more objects. These objects, which also are calledinstances, 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, you learn how to create a new object from any given class.
When using strings during Day 2, “The ABCs of Programming,” you learned that a string literal (a series of characters enclosed in double quotation marks) can be used to create a new instance of the classStringwith the value of that string.
TheStringclass is unusual in that respect. Although it’s a class, it can be assigned a value with a literal as if it was a primitive data type. This shortcut is available only for strings and classes that represent primitive data types, such asIntegerandDouble. To create instances for all other classes, thenewoperator is used.
Usingnew
To create a new object, you use thenewoperator with the name of the class that should be used as a template. The name of the class is followed by parentheses, as in these three examples:
String name =newString("Hal Jordan"); URL address =newURL("http://www.java21days.com"); MarsRobot robbie =newMarsRobot();
The parentheses are important and can’t be omitted. They can be empty, however, in which case the most simple, basic object of that class is created. The parentheses also can contain arguments that determine the values of instance variables or other initial qualities of that object.
Here are two objects being created with arguments:
Random seed =newRandom(606843071); Point pt =newPoint(0, 0);
The number and type of arguments to include inside the parentheses are defined by the class itself using a special method called aconstructor(which is introduced later today). If you try to create a new instance of a class with the wrong number or wrong type of arguments, or if you give it no arguments and it needs them, an error occurs when the program is compiled.
Today’s first project is a demonstration of creating different types of objects with different numbers and types of arguments. TheStringTokenizerclass in thejava.utilpackage divides a string into a series of shorter strings calledtokens.
You divide a string into tokens by applying a 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.
Today’s first project is a Java application that uses string tokens to analyze stock price data. In NetBeans, create a new empty Java file for the classTokenTesterin thecom.java21dayspackage, and enter the code in Listing 3.1 as its source code. This program createsStringTokenizerobjects by usingnewin two different ways and then displays each token the objects contain.
LISTING 3.1 The Full Text ofTokenTester.java
1:packagecom.java21days; 2: 3:importjava.util.StringTokenizer; 4: 5:classTokenTester { 6: 7:public static voidmain(String[] arguments) { 8: StringTokenizer st1, st2; 9: 10: String quote1 ="GOOG 530.80 -9.98"; 11: st1 =newStringTokenizer(quote1); 12: System.out.println("Token 1: "+ st1.nextToken()); 13: System.out.println("Token 2: "+ st1.nextToken()); 14: System.out.println("Token 3: "+ st1.nextToken()); 15: 16: String quote2 ="RHT@75.00@0.22"; 17: st2 =newStringTokenizer(quote2,"@"); 18: System.out.println("\nToken 1: "+ st2.nextToken()); 19: System.out.println("Token 2: "+ st2.nextToken()); 20: System.out.println("Token 3: "+ st2.nextToken()); 21: } 22: }
Save this file by choosing File, Save or clicking Save All on the NetBeans toolbar. Run the application by choosing Run, Run File to see the output displayed inFigure 3.1.
FIGURE 3.1Displaying aStringTokenizerobject’s tokens.
Two differentStringTokenizerobjects are created using different arguments to the constructor.
The first object is created usingnew StringTokenizer()with one argument, aStringobject namedquote1(line 11). This creates aStringTokenizerobject that uses the default delimiters, which are blank spaces, tabs, newlines, carriage returns, or formfeed characters.
If any of these characters is contained in the string, it is used to divide the string. Because thequote1字符串包含空间,这些都是作为delimiters dividing each token. Lines 12–14 display the values of all three tokens: “GOOG”, “530.80”, and “–9.98”.
The secondStringTokenizerobject in this example has two arguments when it is constructed in line 16—aStringobject namedquote2and an at-sign character @. This second argument indicates that the @ character should be used as the delimiter between tokens. TheStringTokenizerobject created in line 17 contains three tokens: “RHT”, “75.00”, and “0.22”.
How Objects Are Constructed
Several things happen when you use thenewoperator. 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 method is called a constructor.
Aconstructoris a way to create 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 additional operations the object requires to initialize itself.
A class can have several different constructors, each with a different number or type of argument. When you usenew, you can specify different arguments in the argument list, and the correct constructor for those arguments is called.
In the TokenTester project, multiple constructor definitions enabled theStringTokenizerclass to accomplish different things with different uses of thenewoperator. When you create your own classes, you can define as many constructors as you need to implement the behavior of the class.
No two constructors in a class can have the same number and type of arguments, because this is the only way constructors are differentiated from each other.
If a class defines no constructors, a constructor with no arguments is called by default when an object of the class is created. The only thing this constructor does is call the same constructor in its superclass.
A Note on Memory Management
If you are familiar with other object-oriented programming languages, you might wonder whether thenewoperator 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 proper amount of memory for that object. You don’t have to allocate any memory for objects explicitly. The Java Virtual Machine (JVM) does it for you.
Because Java memory management is automatic, you don’t need to deallocate the memory an object uses when you’re finished using it. Under most circumstances, when you are finished with an object you have created, Java can determine that the object no longer has any live references to it. (In other words, the object isn’t assigned to any variables still in use or stored in any arrays.)
As a program runs, the JVM periodically looks for unused objects and reclaims the memory that those objects are using. This process is calleddynamic garbage collectionand occurs without any programming on your part. You don’t have to explicitly free the memory taken up by an object; you just have to make sure that you’re not still holding onto an object you want to get rid of.
This feature is one of the most touted advantages of the language over its predecessor C++.