References

Objects and Classes
Objects and classes are central concepts for Java programming. It will take you some
time to master these concepts fully, but since every Java program uses at least a couple of
objects and classes, it is a good idea to have a basic understanding of these concepts right
away.
An object is an entity that you can manipulate in your program, generally by calling
methods. For example, System.out refers to an object, and you saw how to manipulate it
by calling the println method. (Actually, several different methods are available: all
called println, one for printing strings, one for printing integers, one for printing floatingpoint
numbers, and so on.) When you call the println method, some activities occur
inside the object, and the ultimate effect is that the object causes text to appear in the
console window. For now, you should think of objects as a “black box” with a public
interface – the methods you can call – and a hidden implementation – the code and data
that are necessary to make these methods work.
Different objects support different sets of methods. For example, the println method can
be applied to the System.out object, but cannot be applied to the string object “Hello,
World!”. That is, it would be an error to call
“Hello, World!”.println(); // This method call is an error
The reason is simple. The System.out and “Hello World!”
objects belong to different classes. The System.out object is an object of the class
PrintStream, and the “Hello World!” object is an object of the class String. You can apply
the println method to any object of the PrintStream class, but the String class does not
support the println method. The String class supports a good number of other methods;
you will see many of them soon. For example, the length method counts the number of
characters in a string. You can apply that method of type String. Thus,
“Hello, World!”.length(); // This method call is OK
is a correct call – it computes the number 13, the number of characters in the string object
“Hello World!”. (The quotation marks are not counted.)
A class has four purposes:
1. A class specifies the methods that you can use for objects that belong to the class.
2. A class is a factory for objects.
3. A class is a holding place for static methods and objects.
4. A class defines implementation details: the data layout of the objects and the code for
the methods.
In out first program, you saw the third (and least important) purpose. The Hello class
holds the static main method. The System class holds the static out object.

To see how a class can be an object factory, let us turn to another class: the Rectangle
class in the Java class library. Objects of type Rectangle describe rectangular shapes.
Note that a Rectangle object isn’t a rectangular shape – it is a set of numbers that describe
the rectangle. Each rectangle is described by the x- and y-coordinates of its top left
corner, its width, and its height. To make a new rectangle, you need to specify these four
values. For example, you can make a new rectangle with the top left corner at (5,10),
width 20 and height 30 as follows:
new Rectangle(5, 10, 20, 30)
The new operator causes the creation of an object of type Rectangle. The process of
creating a new object is called construction. The four values 5, 10, 20, 30 are called the
construction parameters. Different classes will require different construction parameters.
For example, to construct a Rectangle object, you supply four numbers that describe the
position and the size of the rectangle. To construct a Car object, you might supply the
model name and year.
Actually, some classes let you construct objects in multiple ways. For example, you can
also obtain a rectangle object by supplying no construction parameters at all (but you still
must supply the parentheses):
new Rectangle()
This constructs a (rather useless) rectangle with the top left corner at the origin (0,0),
width 0 and height 0. Construction without parameters is called default construction.
To construct any object you do the following:
1. Use the new operator
2. Give the name of the class
3. Supply construction parameters (if any) inside the parentheses
What can you do with a Rectangle object? Not much, for now. Later will see how to
display rectangles and other shapes in a window. You already know how to print a
description of the rectangle object onto the console window – simply call the
System.out.println method:
System.out.println(new Rectangle(5, 10, 20, 30));
The code prints the line
java.awt.Rectangle[x=5,y=10,width=20,height=30]

Or more specifically, this code creates an object of type Rectangle, then passes that object
to the println method, and finally forgets the object.
Of course, usually you want to do something more to an object than just create it, print it
and forget it. To remember an object, you need to hold it in an object variable. An
object variable is a storage location that stores not the actual object, but information
about the object’s location.
You can create an object variable by giving the name of the class, followed by a name for
the variable. For example,
Rectangle cerealBox;
This statement defines an object variable, cerealBox. The type of this variable is
Rectangle. In Java, every object variable has a particular type. For example, after the
cerealBox variable has been defined by the preceding statement, thereafter in the program
it must always refer to an object of type Rectangle, never to an object of type Car or
String.
However, so far, the cerealBox variable doesn’t yet refer to any object at all. It is an
uninitialized variable. To make cerealBox refer to an object, simply set it to another
object reference. How do you get another object reference? The new operator returns a
reference to a newly created object.
Rectangle cerealBox = new Rectangle(5, 10, 20, 30);
It is very important that you remember that the cerealBox variable does not contain the
object. It refers to the object. You can have two object variables refer to the same
object:
Rectangle crispyCrunchyStuff = cerealBox;
Now you can access the same Rectangle object both as cerealBox and as
crispyCrunchyStuff.
The Rectangle class has over 50 methods, some useful, some less so. To give you a
flavor of manipulating Rectangle objects, let us look at a method of the Rectangle class.
The translate method moves a rectangle by a certain distance in the x- and y-direction.
For example,
cerealBox.translate(15, 25);
moves the rectangle by 15 units in the x-direction and 25 units in the direction and 25
units in the y-direction. Moving a rectangle doesn’t change its width or height, but it
changes the top left corner. For example, the code fragment
Rectangle cerealBox = new Rectangle(5, 10, 20, 30);

prints
cerealBox.translate(15, 25);
System.out.println(cerealBox);
java.awt.Retangle[x=20,y=35,width=20,height=30]
Let’s turn this code fragment into a complete program. As with the Hello program, you
need to carry out three steps:
1. Invent a new class, say MoveRectangle
2. Supply a main method
3. Place instructions inside the main method
However, for this program, there is an additional step that you need to carry out: You
need to import Rectangle class from a package, which is a collection of classes with a
related purpose. All classes in the standard library are contained in packages. For
example, the System class and the String class are in a package called java.lang, and the
Rectangle class belongs to the package java.awt. (The abbreviation awt stands for
“Abstract Windowing Toolkit”). The java.awt package contains many classes for
drawing windows and graphical shapes.
To use the Rectangle class from the java.awt package, simply place the following line at
the top of your program:
import java.awt.Rectangle;
You never need to import classes from the java.lang package. All classes from this
package are automatically imported. For example, you can use the System and String
classes without importing them.
Thus the complete program is:
Program: MoveRectangle.java
import java.awt.Rectangle;
public class MoveRectangle
{
public static void main(String[] args)
{
Rectangle cerealBox = new Rectangle(5, 10, 20, 30);
cerealBox.translate(15, 25);
System.out.println(cerealBox);
}
}