William Hummel's Profile

A string can be built up from smaller pieces using the + operator,
but this is not very efficient. If str is a String and
ch is a character, then executing the command
"str = str + ch;" involves creating a whole new
string that is a copy of str, with the value of ch appended
onto the end. Copying the string takes some time. Building up a long string
letter by letter would require a surprising amount of processing. The class
StringBuffer makes it possible to be efficient about
building up a long string from a number of smaller pieces. To do this,
you must make an object belonging to the StringBuffer
class. For example:

StringBuffer buffer = new StringBuffer();

System.out.println( new Date() );

Of course, to use the Date class in this way, you must make it
available by importing it with one of the statements
"import java.util.Date;" or "import java.util.*;"
at the beginning of your program. (See Subsection 4.5.3
for a discussion of packages and import.)

If randGen is created
with the command:

Random randGen = new Random();

and if N is a positive integer, then randGen.nextInt(N)
generates a random integer in the range from 0 to N-1. For
example, this makes it a little easier to roll a pair of dice. Instead of
saying "die1 = (int)(6*Math.random())+1;", one can say
"die1 = randGen.nextInt(6)+1;". (S

You could say:

java.awt.Color  rectColor;

This is just an ordinary variable declaration of the form
"type-name variable-name;".
Of course, using the full name of every class can get tiresome, so Java makes it
possible to avoid using the full name of a class by importing
the class. If you put

import java.awt.Color;

at the beginning of a Java source code file, then, in the rest of the file,
you can abbreviate the full name java.awt.Color to just the simple name of
the class, Color.

There is a shortcut for importing all
the classes from a given package. You can import all the classes from
java.awt by saying

import java.awt.*;

The "*" is a wildcard that matches every class in the package.
(However, it does not match sub-packages; you cannot import the entire
contents of all the sub-packages of the java package by saying
import java.*.)

I often
use wildcards to import all the classes from the most relevant packages, and use
individual imports when I am using just one or two classes from a given package.

In fact, any Java program that uses a graphical user interface is likely to
use many classes from the java.awt and java.swing packages
as well as from another package named java.awt.event,
and I usually begin such programs with

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

For initialization of static member variables, of course, the situation
is quite different. There is only one copy of a static variable, and
initialization of that variable is executed just once, when the class is first
loaded.

The constructor is declared as "public PairOfDice(int val1, int
val2) ...", with no return type and with the same name as the name of the
class. This is how the Java compiler recognizes a constructor. The constructor
has two parameters, and values for these parameters must be provided when the
constructor is called. For example, the expression "new PairOfDice(3,4)"
would create a PairOfDice object in which the
values of the instance variables die1 and die2 are initially
3 and 4. Of course, in a program, the value returned by the constructor should
be used in some way, as in

PairOfDice dice;            // Declare a variable of type PairOfDice.

dice = new PairOfDice(1,1); // Let dice refer to a new PairOfDice
                            //   object that initially shows 1, 1.

Unlike other subroutines, a constructor can only be called using the
new operator, in an expression that has the form

new class-name ( parameter-list )

where the parameter-list is possibly empty.

A constructor call is more complicated than an ordinary subroutine or
function call. It is helpful to understand the exact steps that the computer
goes through to execute a constructor call:








1. First, the computer gets a block of unused memory in the heap, large enough
   to hold an object of the specified type.
2. It initializes the instance variables of the object. If the declaration of
   an instance variable specifies an initial value, then that value is computed
   and stored in the instance variable. Otherwise, the default initial value is
   used.
3. The actual parameters in the constructor, if any, are evaluated, and the
   values are assigned to the formal parameters of the constructor.
4. The statements in the body of the constructor, if any, are executed.
5. A reference to the object is returned as the value of the constructor
   call.

Objects of type
Student can be created with statements such as:

std = new Student("John Smith");
std1 = new Student("Mary Jones");

In the original version of this class, the value of name had to be
assigned by a program after it created the object of type Student.

For example, the following class could be used to store information
about the person who is using the program:

class UserData {
    static String name;
    static int age;
}

Now, consider a similar class that includes non-static
variables:

class PlayerData {
   String name;
   int age;
}

In this case, there is no such variable as PlayerData.name or
PlayerData.age, since name and age are not static
members of PlayerData. So, there is nothing much in the class at all -- except
the potential to create objects.

n a program, objects are created using an operator called new, which
creates an object and returns a reference to that object. For example, assuming
that std is a variable of type Student, declared as above,
the assignment statement

std = new Student();

It is possible for a variable like std, whose type is given by a
class, to refer to no object at all. We say in this case that std
holds a null reference. The null reference is
written in Java as "null". You can store a null reference in the
variable std by saying

std = null;

and you could test whether the value of std is null by testing

if (std == null) . . .

Suppose that a variable that refers to an object is declared to be
final. This means that the value stored in the variable can never be
changed, once the variable has been initialized. The value stored in the
variable is a reference to the object. So the variable will continue to refer
to the same object as long as the variable exists. However, this does not
prevent the data in the object from changing. The variable is
final, not the object. It's perfectly legal to say

final Student stu = new Student();

stu.name = "John Doe";  // Change data in the object;
                        // The value stored in stu is not changed!
                        // It still refers to the same object.

accessor method that returns the
value of the variable. For example, if your class contains a private
member variable, title, of type String, you
can provide a method

public String getTitle() {
    return title;
}

That is, you might want to make it possible for other classes to specify a new value
for the variable. This is done with a setter method. (If you don't
like simple, Anglo-Saxon words, you can use the fancier term mutator method.)
The name of a setter method should consist of "set" followed by a capitalized copy of
the variable's name, and it should have a parameter with the same type as the
variable. A setter method for the variable title could be written

public void setTitle( String newTitle ) {
   title = newTitle;
}