Sams Teach Yourself Java in 24 Hours, 7th Edition (2014)

---

All shapes except for lines are drawn by calling a method of the Graphics2D class: draw() for outlines and fill() for filled shapes.

The following statement draws the line object created in the previous example:

comp2D.draw(line);

Drawing Rectangles

Rectangles can be filled or unfilled and have rounded or square corners. They are created using the Rectangle2D.Float(int, int, int, int) constructor with these arguments:

The x coordinate at the upper left of the rectangle

The y coordinate at upper left

The width of the rectangle

The height

The following statement draws an unfilled rectangle with square corners:

Rectangle2D.Float box = new Rectangle2D.Float(245F, 65F, 20F, 10F);

This statement creates a rectangle with its upper-left corner at the (x,y) coordinate (245,65) with a width of 20 pixels and a height of 10. To draw this rectangle as an outline, you could use the following statement:

comp2D.draw(box);

If you want to make the rectangle filled in, use the fill() method instead:

comp.fill(box);

You can create rectangles with rounded corners instead of square ones by using the RoundRectangle2D.Float class.

The constructor to this class starts with the same four arguments as the Rectangle2D.Float class and adds the following two arguments:

A number of pixels in the x direction away from the corner of the rectangle

A number of pixels in the y direction away from the corner

These distances are used to determine where the rounding of the rectangle’s corner should begin.

The following statement creates a rounded rectangle:

RoundRectangle2D.Float ro = new RoundRectangle2D.Float(
10F, 10F,
100F, 80F,
15F, 15F);

This rectangle has its upper-left corner at the (10,10) coordinate. The third and fourth arguments specify how wide and tall the rectangle should be. In this case, it should be 100 pixels wide and 80 pixels tall.

The last two arguments to drawRoundRect() specify that all four corners should begin rounding 15 pixels away from the corner at (10,10).

Drawing Ellipses and Circles

You can create ellipses and circles with the same class, Ellipse2D.Float, which takes four arguments:

The x coordinate of the ellipse

The y coordinate of the ellipse

Its width

Its height

The (x,y) coordinates do not indicate a point at the center of the ellipse or circle, as you might expect. Instead, the (x,y) coordinates, width, and height describe an invisible rectangle inside which the ellipse fits. The (x,y) coordinate is the upper-left corner of this rectangle. If it has the same width and height, the ellipse is a circle.

The following statement creates a circle inside the rectangle at the (245,45) coordinate with a height and width of 5 pixels each:

Ellipse2D.Float cir = new Ellipse2D.Float(
245F, 45F, 5F, 5F);

Drawing Arcs

Another circular shape you can draw in Java is an arc, a partial ellipse or circle. Arcs are created using the Arc2D.Float class, which has a constructor method with many of the same arguments. You draw the arc by specifying an ellipse, the portion of the ellipse that should be visible (in degrees), and the place the arc should begin on the ellipse.

To create an arc, specify the following integer arguments to the constructor:

The x coordinate of the invisible rectangle that the ellipse fits into

The y coordinate of the rectangle

The width of the rectangle

The height of the rectangle

The point on the ellipse where the arc should begin (in degrees from 0 to 359)

The size of the arc (also in degrees)

The type of arc it is

The arc’s starting point and size range from 0 to 359 degrees in a counterclockwise direction, beginning with 0 degrees at the 3 o’clock position, as shown in Figure 23.1.

FIGURE 23.1 How arcs are defined in degrees.

The type of arc is specified using class variables: PIE for pie graph slices, CLOSED if the endpoints are connected with a straight line, and OPEN if the endpoints should not be connected.

The following statement draws an open arc at (100,50) that is 120 degrees long, begins at the 30-degree mark, and has a width of 65 and a height of 75:

Arc2D.Float smile = new Arc2D.Float(100F, 50F, 65F, 75F,
30F, 120F, Arc2D.Float.OPEN);

Baking a Pie Graph

To draw this hour to a close, you create PiePanel, a GUI component that displays a pie graph. This component is a subclass of JPanel, a simple Swing container that’s useful as a place to draw something.

One way to begin creating a class is to define the way objects of the class are created. Programs that use the PiePanel class must undertake the following steps:

Create a PiePanel object by using the constructor method PiePanel(int). The integer specified as an argument is the number of slices the pie graph contains.

Call the object’s addSlice(Color, float) method to give a slice the designated color and value.

The value of each slice in PiePanel is the quantity represented by that slice.

For example, Table 23.1 displays data about the status of student loan repayments in the United States for the first 38 years of the program, according to the Office of Postsecondary Education.

TABLE 23.1 U.S. Student Loan Repayments

You could use PiePanel to represent this data in a pie graph with the following statements:

PiePanel loans = new PiePanel(4);
loans.addSlice(Color.green, 101F);
loans.addSlice(Color.yellow, 68F);
loans.addSlice(Color.blue, 91F);
loans.addSlice(Color.red, 25F);

Figure 23.2 shows the result in an application frame that contains one component: a PiePanel created with the student loan data.

FIGURE 23.2 Displaying student loan data on a pie graph.

When a PiePanel object is created, the number of slices is specified in the constructor. You need to know three more things to be able to draw each slice:

The color of the slice, represented by a Color object

The value represented by each slice

The total value represented by all slices

A new helper class, PieSlice, is used to represent each slice in the pie graph:

import java.awt.*;

class PieSlice {
Color color = Color.lightGray;
float size = 0;

PieSlice(Color pColor, float pSize) {
color = pColor;
size = pSize;
}
}

Each slice is constructed by calling PieSlice(Color, float). The combined value of all slices is stored as a private instance variable of the PiePanel class, totalSize. There also are instance variables for the panel’s background color (background) and a counter used to keep track of slices (current):

private int current = 0;
private float totalSize = 0;
private Color background;

Now that you have a PieSlice class to work with, you can create an array of PieSlice objects with another instance variable:

private PieSlice[] slice;

When you create a PiePanel object, none of the slices have an assigned color or size. The only things that you must do in the constructor are define the size of the slice array and save the background color of the panel:

public PiePanel(int sliceCount) {
slice = new PieSlice[sliceCount];
background = getBackground();
}

Use the addSlice(Color, float) method to add a slice of the pie to the panel:

public void addSlice(Color sColor, float sSize) {
if (current <= slice.length) {
slice[current] = new PieSlice(sColor, sSize);
totalSize += sSize;
current++;
}
}

The current instance variable is used to put each slice into its own element of the slice array. The length variable of an array contains the number of elements the array has been defined to hold; as long as current is not larger than slice.length, you can continue adding slices to the panel.

The PiePanel class handles all graphical operations in its paintComponent() method, as you might expect. The trickiest thing about this task is drawing the arcs that represent each slice of the pie.

This is handled in the following statements:

float start = 0;
for (int i = 0; i < slice.length; i++) {
float extent = slice[i].size * 360F / totalSize;
comp2D.setColor(slice[i].color);
Arc2D.Float drawSlice = new Arc2D.Float(
xInset, yInset, width, height, start, extent,
Arc2D.Float.PIE);
start += extent;
comp2D.fill(drawSlice);
}

The start variable keeps track of where to start drawing an arc, and extent keeps track of the size of an arc. If you know the total size of all pie slices and the size of a specific slice, you can figure out extent by multiplying the arc’s size by 360 and dividing that by the total of all slices.

All the arcs are drawn in a for loop: After each arc’s extent is calculated, the arc is created and then extent is added to start. This causes each slice to begin right next to the last one. A call to the Graphics2D method fill() draws the arc.

To bring all this together, create a new empty Java file named PiePanel and enter into it the full text from Listing 23.1.

LISTING 23.1 The Full Text of PiePanel.java