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, 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:

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.

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