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

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 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 learn how to create a new object from
any given class.

In Day 2, "The ABCs of Programming," 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, the use of a string literal serves as a shortcut to create instances of
that class. 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. On Day 5, "Creating Classes and
Methods," you'll learn how to use objects to represent primitive
values.

Using new

To create a new object, you use the new operator 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:

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 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.

In this example, two different StringTokenizer objects are created
using different arguments to the constructor listed after new.

The first instance uses new StringTokenizer() with one argument, a
String object named quote1 (line 9). 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
is called. Multiple constructor definitions 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 deallocate
the memory an object uses when you're finished using the object. 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 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 occurs without requiring 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.