Constructors and Object Creation in Java

Java's standard library contains many classes that solve common problems so that you do not have to write the solutions yourself. This article looks at three of them: Date, which represents times and dates, Random, which produces random numbers, and Color, which represents colors for drawing. Each of them is created with a constructor, and the act of creating one is the starting point for everything that follows.

A constructor is the part of a class that runs when you write new followed by the class name and parentheses. Writing new Date() creates a Date object, and writing new Color(255, 0, 0, 255) creates a Color object. The value you create is connected to a variable, which holds a reference to the object. The variable does not hold the object's contents itself; it points to the object that the constructor produced.

Follow the diagram from the variable. The arrow shows that the variable refers to the object, and the object is the thing the constructor built. Keeping this picture in mind makes the later examples easier to read, because every constructor call in this article follows the same pattern: a new object is built, and a reference to it is stored.

The Date class belongs to the package java.util. Before the class can be used, the program must import it by naming that package. The example below creates a Date with no parameters, which captures the current date and time, and then prints it. The import line tells the compiler where Date lives.

The Random class is a source of random numbers. An object of type Random produces pseudorandom numbers. The word pseudorandom matters: the numbers come from a deterministic procedure that looks random, not from a physical process. The standard function Math.random() uses an object of this kind behind the scenes, so Random is the class that does the actual work whenever Java generates random values. A Random object can produce random integers and random real numbers, and it can also produce Gaussian distributed values, which follow a bell-shaped distribution. This article focuses on integers.

The method nextInt(N) produces integers from 0 up to N minus 1. That means the raw result of nextInt(6) can be 0, 1, 2, 3, 4, or 5, but never 6. To shift the range so that it starts at 1, you add 1 to the result. The expression nextInt(N) + 1 is the standard way to produce integers from 1 through N.

The Color class is in the package java.awt and represents a color that can be used for drawing. You have probably already used constants such as Color.RED. Those constants are final static member variables of the Color class, and their values are themselves objects of type Color. You can also create new Color objects with a constructor that takes four int parameters: the red, green, and blue components, followed by the alpha component.

Each of the first three parameters sets how much red, green, or blue the color contains. A value of 0 means none of that component, and 255 means the maximum possible amount. The fourth parameter, alpha, controls transparency. A larger alpha value produces a more opaque color, so the background shows through less. The class also has other constructors, including one without the alpha parameter that produces fully opaque colors.

A Color object has only a few instance methods that you are likely to use, such as getRed(), which reads one of the color components. There are no setter methods for changing the components. The reason is that a Color is immutable: all of its instance variables are final, so they cannot be changed after the object is created. Once a Color has been built with its four values, those values stay fixed for the life of that object.

This design changes how you work with colors. If you want a different color, you do not modify the existing object. Instead, you create a new Color object with the values you want and point the variable at it. The code below shows this pattern. The first line creates a red Color and the second line gives the variable a new blue Color.

Immutability does not mean that a variable can never be reassigned. The variable c in the previous example was reassigned to a new Color. What cannot happen is changing the internal values of the object that c referred to. The distinction between the variable and the object it refers to is the key to understanding immutability.

The source states that later chapters will show how to write some immutable classes of your own. For now, the important skill is recognizing immutable classes when you meet them and expecting that changes will appear as new objects rather than as edits to existing ones.