objectives - pudn.comread.pudn.com/downloads57/sourcecode/windows/201021/deitel - java how... ·...

12Graphics and Java2D

Objectives• To understand graphics contexts and graphics objects.• To understand and be able to manipulate colors.• To understand and be able to manipulate fonts.• To use Graphics methods to draw lines, rectangles,

rectangles with rounded corners, three-dimensional rectangles, ovals, arcs and polygons.

• To use methods of class Graphics2D from the Java2D API to draw lines, rectangles, rectangles with rounded corners, ellipses, arcs and general paths.

• To be able to specify Paint and Strokecharacteristics of shapes displayed with Graphics2D.

One picture is worth ten thousand words.Chinese proverb

Treat nature in terms of the cylinder, the sphere, the cone, all in perspective.Paul Cezanne

Nothing ever becomes real till it is experienced—even a proverb is no proverb to you till your life has illustrated it.John Keats

A picture shows me at a glance what it takes dozens of pages of a book to expound.Ivan Sergeyevich Turgenev

jhtp5_12.fm Page 569 Sunday, November 24, 2002 11:59 AM

570 Graphics and Java2D Chapter 12

12.1 IntroductionIn this chapter, we overview several of Java’s capabilities for drawing two-dimensionalshapes, controlling colors and controlling fonts. One of Java’s initial appeals was its sup-port for graphics that enabled Java programmers to visually enhance their applets and ap-plications. Java now contains many more sophisticated drawing capabilities as part of theJava2D API. This chapter begins with an introduction to many of the original drawing ca-pabilities of Java. Next, we present several of the new and more powerful Java2D capabil-ities, such as controlling the style of lines used to draw shapes and controlling how shapesare filled with color and patterns.

Figure 12.1 shows a portion of the Java class hierarchy that includes several of thebasic graphics classes and Java2D API classes and interfaces covered in this chapter. ClassColor contains methods and constants for manipulating colors. Class Font containsmethods and constants for manipulating fonts. Class FontMetrics contains methods forobtaining font information. Class Polygon contains methods for creating polygons. ClassGraphics contains methods for drawing strings, lines, rectangles and other shapes. Thebottom half of the figure lists several classes and interfaces from the Java2D API. ClassBasicStroke helps specify the drawing characteristics of lines. Classes GradientPaintand TexturePaint help specify the characteristics for filling shapes with colors or pat-terns. Classes GeneralPath, Arc2D, Ellipse2D, Line2D, Rectangle2D andRoundRectangle2D represent several Java2D shapes.

To begin drawing in Java, we must first understand Java’s coordinate system(Fig. 12.2), which is a scheme for identifying every possible point on the screen. Bydefault, the upper-left corner of a GUI component (such as an applet or a window) has thecoordinates (0, 0). A coordinate pair is composed of an x-coordinate (the horizontal coor-dinate) and a y-coordinate (the vertical coordinate). The x-coordinate is the horizontal dis-tance moving right from the upper-left corner. The y-coordinate is the vertical distancemoving down from the upper-left corner. The x-axis describes every horizontal coordinate,and the y-axis describes every vertical coordinate.

Outline

12.1 Introduction12.2 Graphics Contexts and Graphics Objects12.3 Color Control12.4 Font Control12.5 Drawing Lines, Rectangles and Ovals12.6 Drawing Arcs12.7 Drawing Polygons and Polylines12.8 Java2D API12.9 (Optional Case Study) Thinking About Objects: Designing

Interfaces with the UML

Summary • Terminology • Self-Review Exercises • Answers to Self-Review Exercises • Exercises


Chapter 12 Graphics and Java2D 571

Text and shapes are displayed on the screen by specifying coordinates. Coordinateunits are measured in pixels. A pixel is a display monitor’s smallest unit of resolution.

The upper-left coordinate (0, 0) of a window is behind the title bar of the window. Forthis reason, drawing coordinates should be adjusted to draw inside the borders of thewindow. Class Container (a superclass of all windows in Java) has method getInsets,which returns an Insets object (package java.awt) for this purpose. An Insets objecthas four public members—top, bottom, left and right—that represent the numberof pixels from each edge of the window to the drawing area for the window.

Fig. 12.1 Classes and interfaces used in this chapter from Java’s original graphics capabilities and from the Java2D API. [Note: Class Object appears here because it is the superclass of the Java class hierarchy.]

Classes and interfaces from the Java2D API that appear in package java.awt

Object

Color

Component

Font

FontMetrics

Graphics

GradientPaint

RectangularShape

RoundRectangle2D

«interface»java.awt.Paint

Graphics2D

Polygon

BasicStroke

TexturePaint

GeneralPath

Line2D

Arc2D

Ellipse2D

Rectangle2D

«interface»java.awt.Shape

«interface»java.awt.Stroke

Classes from the Java2D API that appear in package java.awt.geom



Portability Tip 12.1Different display monitors have different resolutions (i.e., the density of pixels varies). Thiscan cause graphics to appear to be different sizes on different monitors or on the same mon-itor with different settings. 12.1

12.2 Graphics Contexts and Graphics ObjectsA Java graphics context enables drawing on the screen. A Graphics object manages agraphics context and draws pixels on the screen that represent text and other graphical ob-ject (such as lines, ellipses, rectangles and other polygons). Graphics objects containmethods for drawing, font manipulation, color manipulation and the like. Every applet wehave seen in the text that performs drawing on the screen has used the Graphics object g(the argument to the applet’s paint method) to manage the applet’s graphics context. Inthis chapter, we demonstrate drawing in applications. However, every technique shownhere can be used in applets.

The Graphics class is an abstract class (i.e., Graphics objects cannot be instan-tiated). This contributes to Java’s portability. Because drawing is performed differently oneach platform that supports Java, there cannot be one implement action of the drawingcapabilities on all systems. For example, the graphics capabilities that enable a PC runningMicrosoft Windows to draw a rectangle are different from the graphics capabilities thatenable a Linux workstation to draw a rectangle—and those are both different from thegraphics capabilities that enable a Macintosh to draw a rectangle. When Java is imple-mented on each platform, a subclass of Graphics is created that implements the drawingcapabilities. This implementation is hidden from us by class Graphics, which supplies theinterface that enables us to use graphics in a platform-independent manner.

Class Component is the superclass for many of the classes in the java.awt package.(We discuss class Component in Chapter 13.) Component method paint takes aGraphics object as an argument. This object is passed to the paint method by the systemwhen a paint operation is required for a Component. The header for the paint method is

public void paint( Graphics g )

Graphics reference g receives a reference to an instance of the system-specific subclassthat Graphics extends. The preceding method header should look familiar to you—it is

Fig. 12.2 Java coordinate system. Units are measured in pixels.

X axis

Y axis

(0, 0)

(x, y)

+x

+y



the same one we have been using in our applet classes. Actually, class Component is anindirect superclass of JApplet—the superclass of every applet in this book. Many capa-bilities of class JApplet are inherited from class Component.

Method paint is seldom called directly by the programmer because drawing graphicsis an event-driven process. When an applet executes, the applet container calls methodpaint (after calls to the methods init and start). For paint to be called again, an eventmust occur (such as covering and uncovering the applet with another window). Similarly,when any Component is displayed, that Component’s paint method is called.

If the programmer needs to call paint, a call is made to Component methodrepaint. This method requests a call to the Component class update method as soon aspossible to clear the Component’s background of any previous drawing, then update callspaint directly. Method repaint is frequently called by the programmer to force a paintoperation. Method repaint should not be overridden, because it performs some system-dependent tasks. The headers for repaint and update are

public void repaint()public void update( Graphics g )

Method update takes a Graphics object as an argument, which is supplied automaticallyby the system when update is called.

In this chapter, we focus on method paint. In the next chapter, we discuss the event-driven nature of graphics and methods repaint and update in more detail. We also dis-cuss in that chapter class JComponent—a superclass of many GUI components in packagejavax.swing. Subclasses of JComponent typically paint from their paintComponentmethods.

12.3 Color ControlColors enhance the appearance of a program and help convey meaning. For example, a traf-fic light has three different color lights—red indicates stop, yellow indicates caution andgreen indicates go.

Class Color declares methods and constants for manipulating colors in a Java pro-gram. The predeclared color constants are summarized in Fig. 12.3,1 and several colormethods and constructors are summarized in Fig. 12.4. Note that two of the methods inFig. 12.4 are Graphics methods that are specific to colors.

1. In prior versions of Java, the Color constants had names consisting of lowercase and uppercaseletters. Although those names are still available, the names shown in Fig. 12.3 are preferred be-cause they conform to the naming conventions for constants.

Color constant Color RGB value

public final static Color ORANGE orange 255, 200, 0

public final static Color PINK pink 255, 175, 175

public final static Color CYAN cyan 0, 255, 255

Fig. 12.3 Color constants and their RGB values. (Part 1 of 2.)

jhtp5_12.fm 73 Sunday, November 24, 2002 11:59 AM


Every color is created from a red, a green and a blue component. Together these com-ponents are called RGB values. All three RGB components can be integers in the range

public final static Color MAGENTA magenta 255, 0, 255

public final static Color YELLOW yellow 255, 255, 0

public final static Color BLACK black 0, 0, 0

public final static Color WHITE white 255, 255, 255

public final static Color GRAY gray 128, 128, 128

public final static Color LIGHT_GRAY light gray 192, 192, 192

public final static Color DARK_GRAY dark gray 64, 64, 64

public final static Color RED red 255, 0, 0

public final static Color GREEN green 0, 255, 0

public final static Color BLUE blue 0, 0, 255

Method Description

Color constructors and methods

public Color( int r, int g, int b )

Creates a color based on red, green and blue components expressed as integers from 0 to 255.

public Color( float r, float g, float b )

Creates a color based on red, green and blue components expressed as floating-point values from 0.0 to 1.0.

public int getRed()

Returns a value between 0 and 255 representing the red content.

public int getGreen()

Returns a value between 0 and 255 representing the green content.

public int getBlue()

Returns a value between 0 and 255 representing the blue content.

Graphics methods for manipulating Colors

public Color getColor()

Returns a Color object representing the current color for the graphics context.

public void setColor( Color c )

Sets the current color for drawing with the graphics context.

Fig. 12.4 Color methods and color-related Graphics methods .

Color constant Color RGB value

Fig. 12.3 Color constants and their RGB values. (Part 2 of 2.)



from 0 to 255, or they can be floating-point values in the range 0.0 to 1.0. The first RGBcomponent specifies the amount of red, the second specifies the amount of green and thethird specifies the amount of blue. The larger the RGB value, the greater the amount of thatparticular color. Java enables the programmer to choose from 256 × 256 × 256 (or approx-imately 16.7 million) colors. However, not all computers are capable of displaying all thesecolors. If this is the case, the computer will display the closest color it can.

Two Color constructors are shown in Fig. 12.4—one that takes three int argumentsand one that takes three float arguments, with each argument specifying the amount ofred, green and blue. The int values must be in the range 0–255 and the float values mustbe in the range 0.0–1.0. The new Color object will have the specified amounts of red,green and blue. Color methods getRed, getGreen and getBlue return integer valuesfrom 0 to 255 representing the amount of red, green and blue, respectively. Graphicsmethod getColor returns a Color object representing the current drawing color.Graphics method setColor sets the current drawing color.

The application of Fig. 12.5 demonstrates several methods from Fig. 12.4 by drawingfilled rectangles and strings in several different colors.

1 // Fig. 12.5: ShowColors.java2 // Demonstrating Colors.3 import java.awt.*;4 import javax.swing.*;56 public class ShowColors extends JFrame {78 // constructor sets window's title bar string and dimensions9 public ShowColors()

10 {11 super( "Using colors" );1213 setSize( 400, 130 );14 setVisible( true );15 }1617 // draw rectangles and Strings in different colors18 public void paint( Graphics g )19 {20 // call superclass's paint method21 super.paint( g );2223 // set new drawing color using integers2425 g.fillRect( 25, 25, 100, 20 );26 g.drawString( "Current RGB: " + , 130, 40 );2728 // set new drawing color using floats2930 g.fillRect( 25, 50, 100, 20 );31 g.drawString( "Current RGB: " + , 130, 65 );32

Fig. 12.5 Color changed for drawing. (Part 1 of 2.)

g.setColor( new Color( 255, 0, 0 ) );

g.getColor()

g.setColor( new Color( 0.0f, 1.0f, 0.0f ) );

g.getColor()



When the application begins execution, class ShowColors’s paint method (lines 18–45) is called to paint the window. Line 24 uses Graphics method setColor to set the cur-rent drawing color. Method setColor receives a Color object. The expressionnew Color( 255, 0, 0 ) creates a new Color object that represents red (red value 255,and 0 for the green and blue values). Line 25 uses Graphics method fillRect to draw afilled rectangle in the current color. Method fillRect receives the same parameters asmethod drawRect (discussed in Chapter 3). Line 26 uses Graphics method drawStringto draw a String in the current color. The expression g.getColor() retrieves the currentcolor from the Graphics object. The returned Color object is concatenated with string"Current RGB: ", resulting in an implicit call to class Color’s toString method.Notice that the String representation of the Color object contains the class name andpackage (java.awt.Color), and the red, green and blue values.

Lines 29–31 and lines 34–36 perform the same tasks again. Line 29 uses the Colorconstructor with three float arguments to create the color green (0.0f for red, 1.0f forgreen and 0.0f for blue). Note the syntax of the values. The letter f appended to a floating-point literal indicates that the literal should be treated as type float. By default, floating-point literals are treated as type double.

33 // set new drawing color using static Color objects3435 g.fillRect( 25, 75, 100, 20 );36 g.drawString( "Current RGB: " + g.getColor(), 130, 90 );3738 // display individual RGB values394041 g.fillRect( 25, 100, 100, 20 );42 g.drawString( "RGB values: " + + ", " +43 + ", " + , 130, 115 );4445 } // end method paint4647 // execute application48 public static void main( String args[] )49 {50 ShowColors application = new ShowColors();51 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );52 }5354 } // end class ShowColors

Fig. 12.5 Color changed for drawing. (Part 2 of 2.)

g.setColor( Color.BLUE );

Color color = Color.MAGENTA;g.setColor( color );

color.getRed()color.getGreen() color.getBlue()



Line 34 sets the current drawing color to one of the predeclared Color constants(Color.BLUE). Note that new is not needed to create the constant. The Color constantsare static, so they are created when class Color is loaded into memory at execution time.

The statement at lines 42–43 demonstrates Color methods getRed, getGreen andgetBlue on the predeclared Color.MAGENTA object.

Software Engineering Observation 12.1To change the color, you must create a new Color object (or use one of the predeclaredColor constants). Color objects are not modifiable (also called immutable). 12.1

Package javax.swing provides the JColorChooser GUI component to enableapplication users to select colors. Figure 12.6 enables you to press a button to display aJColorChooser dialog. When you select a color and press the dialog’s OK button, thebackground color of the application window changes colors.

1 // Fig. 12.6: ShowColors2.java2 // Choosing colors with JColorChooser.3 import java.awt.*;4 import java.awt.event.*;5 import javax.swing.*;67 public class ShowColors2 extends JFrame {8 private JButton changeColorButton;9 private Color color = Color.LIGHT_GRAY;

10 private Container container;1112 // set up GUI13 public ShowColors2()14 {15 super( "Using JColorChooser" );1617 container = getContentPane();18 container.setLayout( new FlowLayout() );1920 // set up changeColorButton and register its event handler21 changeColorButton = new JButton( "Change Color" );22 changeColorButton.addActionListener(2324 new ActionListener() { // anonymous inner class2526 // display JColorChooser when user clicks button27 public void actionPerformed( ActionEvent event )28 {29303132 // set default color, if no color is returned 33 if ( color == null )34 color = Color.LIGHT_GRAY;35

Fig. 12.6 JColorChooser dialog. (Part 1 of 2.)

color = JColorChooser.showDialog( ShowColors2.this, "Choose a color", color );



36 // change content pane's background color3738 }3940 } // end anonymous inner class4142 ); // end call to addActionListener4344 container.add( changeColorButton );4546 setSize( 400, 130 );47 setVisible( true );4849 } // end ShowColor2 constructor5051 // execute application52 public static void main( String args[] )53 {54 ShowColors2 application = new ShowColors2();55 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );56 }5758 } // end class ShowColors2

Fig. 12.6 JColorChooser dialog. (Part 2 of 2.)

container.setBackground( color );

Select a color from one of the color swatches.



Lines 29–30 in actionPerformed use JColorChooser static method showDialogto display the color chooser dialog. This method returns the selected Color object, or nullif the user presses Cancel or closes the dialog without pressing OK. The method takesthree arguments—a reference to its parent Component, a String to display in the title barof the dialog and the initial selected Color for the dialog. The parent component is a ref-erence to the window from which the dialog is displayed. The dialog will be centered onthe parent. If the parent is null, the dialog is centered on the screen. While the colorchooser dialog is on the screen, the user cannot interact with the parent component. Thistype of dialog is called a modal dialog (discussed in Chapter 14). Notice the special syntaxShowColors2.this used in line 30. Recall from Section 10.9 that you can access theouter class object’s this reference by qualifying this with the name of the outer class anda dot (.).

After the user selects a color, lines 33–34 determine whether color is null, and, ifso, sets color to the default Color.LIGHT_GRAY. Line 37 uses method setBackgroundto change the background color of the content pane (represented by container in this pro-gram). Method setBackground is one of the many Component methods that can be usedon most GUI components.

The second screen capture of Fig. 12.6 demonstrates the default JColorChooserdialog that allows the user to select a color from a variety of color swatches. Notice thatthere are actually three tabs across the top of the dialog—Swatches, HSB and RGB.These represent three different ways to select a color. The HSB tab allows you to select acolor based on hue, saturation and brightness. The RGB tab allows you to select a color byusing sliders to select the red, green and blue components of the color. The HSB and RGBtabs are shown in Fig. 12.7.

Fig. 12.7 HSB and RGB tabs of the JColorChooser dialog. (Part 1 of 2.)



12.4 Font ControlThis section introduces methods and constants for font control. Most font methods and fontconstants are part of class Font. Some methods of class Font and class Graphics aresummarized in Fig. 12.8.

Method or constant Description

Font constants, constructors and methods for drawing polygons

public final static int PLAIN

A constant representing a plain font style.

public final static int BOLD

A constant representing a bold font style.

public final static int ITALIC

A constant representing an italic font style.

public Font( String name, int style, int size )

Creates a Font object with the specified font, style and size.

public int getStyle()

Returns an integer value indicating the current font style.

public int getSize()

Returns an integer value indicating the current font size.

public String getName()

Returns the current font name as a string.

Fig. 12.8 Font-related methods and constants. (Part 1 of 2.)

Fig. 12.7 HSB and RGB tabs of the JColorChooser dialog. (Part 2 of 2.)

Sliders to select the red, green and blue color components



Class Font’s constructor takes three arguments—the font name, font style and fontsize. The font name is any font currently supported by the system in which the program isrunning, such as standard Java fonts Monospaced, SansSerif and Serif. The font styleis Font.PLAIN, Font.ITALIC or Font.BOLD (each is a static field of class Font).Font styles can be used in combination (e.g., Font.ITALIC + Font.BOLD). The font sizeis measured in points. A point is 1/72 of an inch. Graphics method setFont sets the cur-rent drawing font—the font in which text will be displayed—to its Font argument.

Portability Tip 12.2The number of fonts varies greatly across systems. Java guarantees that the fonts Serif,Monospaced, SansSerif, Dialog and DialogInput will be available. 12.2

Common Programming Error 12.1Specifying a font that is not available on a system is a logic error. Java will substitute thatsystem’s default font—typically Serif. 12.1

Figure 12.9 displays text in four different fonts, with each font in a different size. Theprogram uses the Font constructor to initialize Font objects (at lines 24, 28, 32 and 37)

public String getFamily()

Returns the font’s family name as a string.

public boolean isPlain()

Tests a font for a plain font style. Returns true if the font is plain.

public boolean isBold()

Tests a font for a bold font style. Returns true if the font is bold.

public boolean isItalic()

Tests a font for an italic font style. Returns true if the font is italic.

Graphics methods for manipulating Fonts

public Font getFont()

Returns a Font object reference representing the current font.

public void setFont( Font f )

Sets the current font to the font, style and size specified by the Fontobject reference f.

Method or constant Description

Fig. 12.8 Font-related methods and constants. (Part 2 of 2.)

1 // Fig. 12.9: Fonts.java2 // Using fonts.3 import java.awt.*;4 import javax.swing.*;56 public class Fonts extends JFrame {7

Fig. 12.9 Graphics method setFont changes the drawing font. (Part 1 of 2.)



8 // set window's title bar and dimensions9 public Fonts()

10 {11 super( "Using fonts" );1213 setSize( 420, 125 );14 setVisible( true );15 }1617 // display Strings in different fonts and colors18 public void paint( Graphics g )19 {20 // call superclass's paint method21 super.paint( g );2223 // set font to Serif (Times), bold, 12pt and draw a string 2425 g.drawString( "Serif 12 point bold.", 20, 50 );2627 // set font to Monospaced (Courier), italic, 24pt and draw a string 2829 g.drawString( "Monospaced 24 point italic.", 20, 70 );3031 // set font to SansSerif (Helvetica), plain, 14pt and draw a string 3233 g.drawString( "SansSerif 14 point plain.", 20, 90 );3435 // set font to Serif (Times), bold/italic, 18pt and draw a string36 g.setColor( Color.RED );3738 g.drawString( + " " + +39 " point bold italic.", 20, 110 );4041 } // end method paint4243 // execute application44 public static void main( String args[] )45 {46 Fonts application = new Fonts();47 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );48 }4950 } // end class Fonts

Fig. 12.9 Graphics method setFont changes the drawing font. (Part 2 of 2.)

g.setFont( new Font( "Serif", Font.BOLD, 12 ) );

g.setFont( new Font( "Monospaced", Font.ITALIC, 24 ) );

g.setFont( new Font( "SansSerif", Font.PLAIN, 14 ) );

g.setFont( new Font( "Serif", Font.BOLD + Font.ITALIC, 18 ) );g.getFont().getName() g.getFont().getSize()



passed to Graphics method setFont to change the drawing font. Each call to the Fontconstructor passes a font name (Serif, Monospaced or SansSerif) as a string, a fontstyle (Font.PLAIN, Font.ITALIC or Font.BOLD) and a font size. Once Graphicsmethod setFont is invoked, all text displayed following the call will appear in the newfont until the font is changed. Note that line 36 changes the drawing color to red, so the nextstring displayed appears in red.

Software Engineering Observation 12.2To change the font, you must create a new Font object. Font objects are immutable—Fonthas no set methods to change the characteristics of the current font. 12.2

Font MetricsSometimes, it is necessary to get information about the current drawing font, such as thefont name, the font style and the font size. Several Font methods used to get font informa-tion are summarized in Fig. 12.8. Method getStyle returns an integer value representingthe current style. The integer value returned is either Font.PLAIN, Font.ITALIC,Font.BOLD or the combination of Font.ITALIC and Font.BOLD.

Method getSize returns the font size in points. Method getName returns the currentfont name as a string. Method getFamily returns the name of the font family to which thecurrent font belongs. The name of the font family is platform specific.

Font methods are also available to test the style of the current font and are summarizedin Fig. 12.8. Methods isPlain, isBold and isItalic return true if the current fontstyle is plain, bold or italic, respectively.

Sometimes precise information about a font’s metrics must be known—such as height,descent (the amount a character dips below the baseline), ascent (the amount a characterrises above the baseline) and leading (the difference between the descent of one line of textand the ascent of the line of text below it—i.e., the interline spacing). Figure 12.10 illus-trates some of the common font metrics. Note that the coordinate passed to drawStringcorresponds to the lower-left corner of the baseline of the font.

Class FontMetrics declares several methods for obtaining font metrics. Thesemethods and Graphics method getFontMetrics are summarized in Fig. 12.11.Figure 12.12 uses the methods of Fig. 12.11 to obtain font metric information for two fonts.

Fig. 12.10 Font metrics.

height Xy1Õ ascent

leading

baselinedescent



Method Description

FontMetrics methods

public int getAscent()

Returns a value representing the ascent of a font in points.

public int getDescent()

Returns a value representing the descent of a font in points.

public int getLeading()

Returns a value representing the leading of a font in points.

public int getHeight()

Returns a value representing the height of a font in points.

Graphics methods for getting a Font’s FontMetrics

public FontMetrics getFontMetrics()

Returns the FontMetrics object for the current drawing Font.

public FontMetrics getFontMetrics( Font f )

Returns the FontMetrics object for the specified Font argument.

Fig. 12.11 FontMetrics and Graphics methods for obtaining font metrics.

1 // Fig. 12.12: Metrics.java2 // FontMetrics and Graphics methods useful for obtaining font metrics.3 import java.awt.*;4 import javax.swing.*;56 public class Metrics extends JFrame {78 // set window's title bar String and dimensions9 public Metrics()

10 {11 super( "Demonstrating FontMetrics" );1213 setSize( 510, 210 );14 setVisible( true );15 }1617 // display font metrics18 public void paint( Graphics g )19 {20 super.paint( g ); // call superclass's paint method2122 g.setFont( new Font( "SansSerif", Font.BOLD, 12 ) );2324 g.drawString( "Current font: " + , 10, 40 );25 g.drawString( "Ascent: " + 26 g.drawString( "Descent: " + , 10, 70 );

Fig. 12.12 Font metrics. (Part 1 of 2.)

FontMetrics metrics = g.getFontMetrics();g.getFont()

metrics.getAscent(), 10, 55 );metrics.getDescent()



Line 22 creates and sets the current drawing font to a SansSerif, bold, 12-point font.Line 23 uses Graphics method getFontMetrics to obtain the FontMetrics object forthe current font. Line 24 uses an implicit call to class Font’s toString method to outputthe string representation of the font. Lines 25–28 use FontMetric methods to obtain theascent, descent, height and leading for the font.

Line 30 creates a new Serif, italic, 14-point font. Line 31 uses a second version ofGraphics method getFontMetrics, which receives a Font argument and returns a cor-responding FontMetrics object. Lines 34–37 obtain the ascent, descent, height andleading for the font. Notice that the font metrics are slightly different for the two fonts.

12.5 Drawing Lines, Rectangles and OvalsThis section presents several Graphics methods for drawing lines, rectangles and ovals.The methods and their parameters are summarized in Fig. 12.13. For each drawing methodthat requires a width and height parameter, the width and height must be nonnegative

27 g.drawString( "Height: " + , 10, 85 );28 g.drawString( "Leading: " + , 10, 100 );2930 Font font = new Font( "Serif", Font.ITALIC, 14 );3132 g.setFont( font );33 g.drawString( "Current font: " + font, 10, 130 );34 g.drawString( "Ascent: " + , 10, 145 );35 g.drawString( "Descent: " + , 10, 160 );36 g.drawString( "Height: " + , 10, 175 );37 g.drawString( "Leading: " + , 10, 190 );3839 } // end method paint4041 // execute application42 public static void main( String args[] )43 {44 Metrics application = new Metrics();45 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );46 }4748 } // end class Metrics

Fig. 12.12 Font metrics. (Part 2 of 2.)

metrics.getHeight()metrics.getLeading()

metrics = g.getFontMetrics( font );

metrics.getAscent()metrics.getDescent()

metrics.getHeight()metrics.getLeading()



values. Otherwise, the shape will not display. Figure 12.14 demonstrates drawing a varietyof lines, rectangles, three-dimensional rectangles, rounded rectangles and ovals.

Method Description

public void drawLine( int x1, int y1, int x2, int y2 )

Draws a line between the point (x1, y1) and the point (x2, y2).

public void drawRect( int x, int y, int width, int height )

Draws a rectangle of the specified width and height. The top-left corner of the rectangle has the coordinates (x, y).

public void fillRect( int x, int y, int width, int height )

Draws a solid rectangle with the specified width and height. The top-left cor-ner of the rectangle has the coordinate (x, y).

public void clearRect( int x, int y, int width, int height )

Draws a solid rectangle with the specified width and height in the current background color. The top-left corner of the rectangle has the coordinate (x, y).

public void drawRoundRect( int x, int y, int width, int height,int arcWidth, int arcHeight )

Draws a rectangle with rounded corners in the current color with the specified width and height. The arcWidth and arcHeight determine the rounding of the corners (see Fig. 12.15).

public void fillRoundRect( int x, int y, int width, int height,int arcWidth, int arcHeight )

Draws a solid rectangle with rounded corners in the current color with the speci-fied width and height. The arcWidth and arcHeight determine the rounding of the corners (see Fig. 12.15).

public void draw3DRect( int x, int y, int width, int height, boolean b )

Draws a three-dimensional rectangle in the current color with the specified width and height. The top-left corner of the rectangle has the coordinates (x, y). The rectangle appears raised when b is true and lowered when b is false.

public void fill3DRect( int x, int y, int width, int height, boolean b )

Draws a filled three-dimensional rectangle in the current color with the specified width and height. The top-left corner of the rectangle has the coordinates (x, y). The rectangle appears raised when b is true and lowered when b is false.

public void drawOval( int x, int y, int width, int height )

Draws an oval in the current color with the specified width and height. The bounding rectangle’s top-left corner is at the coordinates (x, y). The oval touches all four sides of the bounding rectangle at the center of each side (see Fig. 12.16).

public void fillOval( int x, int y, int width, int height )

Draws a filled oval in the current color with the specified width and height. The bounding rectangle’s top-left corner is at the coordinates (x, y). The oval touches all four sides of the bounding rectangle at the center of each side (see Fig. 12.16).

Fig. 12.13 Graphics methods that draw lines, rectangles and ovals.



1 // Fig. 12.14: LinesRectsOvals.java2 // Drawing lines, rectangles and ovals.3 import java.awt.*;4 import javax.swing.*;56 public class LinesRectsOvals extends JFrame {78 // set window's title bar String and dimensions9 public LinesRectsOvals()

10 {11 super( "Drawing lines, rectangles and ovals" );1213 setSize( 400, 165 );14 setVisible( true );15 }1617 // display various lines, rectangles and ovals18 public void paint( Graphics g )19 {20 super.paint( g ); // call superclass's paint method2122 g.setColor( Color.RED );232425 g.setColor( Color.BLUE );26272829 g.setColor( Color.CYAN );30313233 g.setColor( Color.YELLOW ); 34353637 g.setColor( Color.MAGENTA );38394041 } // end method paint4243 // execute application44 public static void main( String args[] )45 {46 LinesRectsOvals application = new LinesRectsOvals();47 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );48 }4950 } // end class LinesRectsOvals

Fig. 12.14 Drawing lines, rectangles and ovals. (Part 1 of 2.)

g.drawLine( 5, 30, 350, 30 );

g.drawRect( 5, 40, 90, 55 ); g.fillRect( 100, 40, 90, 55 );

g.fillRoundRect( 195, 40, 90, 55, 50, 50 );g.drawRoundRect( 290, 40, 90, 55, 20, 20 );

g.draw3DRect( 5, 100, 90, 55, true ); g.fill3DRect( 100, 100, 90, 55, false );

g.drawOval( 195, 100, 90, 55 );g.fillOval( 290, 100, 90, 55 );



Methods fillRoundRect (line 30) and drawRoundRect (line 31) draw rectangleswith rounded corners. Their first two arguments specify the coordinates of the upper-leftcorner of the bounding rectangle—the area in which the rounded rectangle will be drawn.Note that the upper-left corner coordinates are not the edge of the rounded rectangle, butthe coordinates where the edge would be if the rectangle had square corners. The third andfourth arguments specify the width and height of the rectangle. Their last two argu-ments—arcWidth and arcHeight—determine the horizontal and vertical diameters ofthe arcs used to represent the corners.

Figure 12.15 labels the arc width, arc height, width and height of a rounded rectangle.Using the same value for arcWidth and arcHeight produces a quarter circle at eachcorner. When width, height, arcWidth and arcHeight have the same values, the resultis a circle. If the values for width and height are the same and the values of arcWidthand arcHeight are 0, the result is a square.

Methods draw3DRect (line 34 of Fig. 12.14) and fill3DRect (line 35) take the samearguments. The first two arguments specify the top-left corner of the rectangle. The nexttwo arguments specify the width and height of the rectangle, respectively. The last argu-ment determines whether the rectangle is raised (true) or lowered (false). The three-dimensional effect of draw3DRect appears as two edges of the rectangle in the originalcolor and two edges in a slightly darker color. The three-dimensional effect offill3DRect appears as two edges of the rectangle in the original drawing color and thefill and other two edges in a slightly darker color. Raised rectangles have the original

Fig. 12.15 Arc width and arc height for rounded rectangles.

Fig. 12.14 Drawing lines, rectangles and ovals. (Part 2 of 2.)

drawRect

drawLine

fillRect

draw3DRect

fill3DRect

fillRoundRect

drawRoundRect

drawOval

fillOval

(x, y)

arc height

arc width

width

height



drawing color edges at the top and left of the rectangle. Lowered rectangles have the orig-inal drawing color edges at the bottom and right of the rectangle. The three-dimensionaleffect is difficult to see in some colors.

The drawOval and fillOval methods (lines 38–39) take the same four arguments.The first two arguments specify the top-left coordinate of the bounding rectangle that con-tains the oval. The last two arguments specify the width and height of the bounding rect-angle, respectively. Figure 12.16 shows an oval bounded by a rectangle. Note that the ovaltouches the center of all four sides of the bounding rectangle. (The bounding rectangle isnot displayed on the screen.)

12.6 Drawing ArcsAn arc is drawn as a portion of an oval. Arc angles are measured in degrees. Arcs sweepfrom a starting angle by the number of degrees specified by their arc angle. The startingangle indicates in degrees where the arc begins. The arc angle specifies the total number ofdegrees through which the arc sweeps. Figure 12.17 illustrates two arcs. The left set of axesshows an arc sweeping from zero degrees to approximately 110 degrees. Arcs that sweepin a counterclockwise direction are measured in positive degrees. The right set of axesshows an arc sweeping from zero degrees to approximately –110 degrees. Arcs that sweepin a clockwise direction are measured in negative degrees. Notice the dashed boxes aroundthe arcs in Fig. 12.17. When drawing an arc, we specify a bounding rectangle for an oval.The arc will sweep along part of the oval. Graphics methods drawArc and fillArc fordrawing arcs are summarized in Fig. 12.18.

Fig. 12.16 Oval bounded by a rectangle.

Fig. 12.17 Positive and negative arc angles.

(x, y)

height

width

90°

0°180°

270°

90°

0°180°

270°

Positive angles Negative angles



Figure 12.19 demonstrates the arc methods of Fig. 12.18. The program draws six arcs(three unfilled and three filled). To illustrate the bounding rectangle that helps determinewhere the arc appears, the first three arcs are displayed inside a yellow rectangle that hasthe same x, y, width and height arguments as the arcs.

Method Description

public void drawArc( int x, int y, int width, int height, int startAngle,int arcAngle )

Draws an arc relative to the bounding rectangle’s top-left coordinates (x, y) with the specified width and height. The arc segment is drawn starting at startAn-gle and sweeps arcAngle degrees.

public void fillArc( int x, int y, int width, int height, int startAngle,int arcAngle )

Draws a solid arc (i.e., a sector) relative to the bounding rectangle’s top-left coor-dinates (x, y) with the specified width and height. The arc segment is drawn starting at startAngle and sweeps arcAngle degrees.

Fig. 12.18 Graphics methods for drawing arcs.

1 // Fig. 12.19: DrawArcs.java2 // Drawing arcs.3 import java.awt.*;4 import javax.swing.*;56 public class DrawArcs extends JFrame {78 // set window's title bar String and dimensions9 public DrawArcs()

10 {11 super( "Drawing Arcs" );1213 setSize( 300, 170 );14 setVisible( true );15 }1617 // draw rectangles and arcs18 public void paint( Graphics g )19 {20 super.paint( g ); // call superclass's paint method2122 // start at 0 and sweep 360 degrees23 g.setColor( Color.YELLOW );24 g.drawRect( 15, 35, 80, 80 );25 g.setColor( Color.BLACK );2627

Fig. 12.19 Arcs displayed with drawArc and fillArc. (Part 1 of 2.)

g.drawArc( 15, 35, 80, 80, 0, 360 );



12.7 Drawing Polygons and PolylinesPolygons are closed multisided shapes composed of straight line segments. Polylines are asequence of connected points. Graphics methods for drawing polygons and polylines arediscussed in Fig. 12.20. Note that some methods require a Polygon object (package ja-va.awt). Class Polygon’s constructors are also described in Fig. 12.20. Figure 12.21draws polygons and polylines, using the methods and constructors in Fig. 12.20.

28 // start at 0 and sweep 110 degrees29 g.setColor( Color.YELLOW );30 g.drawRect( 100, 35, 80, 80 );31 g.setColor( Color.BLACK );323334 // start at 0 and sweep -270 degrees35 g.setColor( Color.YELLOW );36 g.drawRect( 185, 35, 80, 80 );37 g.setColor( Color.BLACK );383940 // start at 0 and sweep 360 degrees414243 // start at 270 and sweep -90 degrees444546 // start at 0 and sweep -270 degrees474849 } // end method paint5051 // execute application52 public static void main( String args[] )53 {54 DrawArcs application = new DrawArcs();55 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );56 }5758 } // end class DrawArcs

Fig. 12.19 Arcs displayed with drawArc and fillArc. (Part 2 of 2.)

g.drawArc( 100, 35, 80, 80, 0, 110 );

g.drawArc( 185, 35, 80, 80, 0, -270 );

g.fillArc( 15, 120, 80, 40, 0, 360 );

g.fillArc( 100, 120, 80, 40, 270, -90 );

g.fillArc( 185, 120, 80, 40, 0, -270 );



Method Description

Graphics methods for drawing polygons

public void drawPolygon( int xPoints[], int yPoints[], int points )

Draws a polygon. The x-coordinate of each point is specified in the xPointsarray and the y-coordinate of each point is specified in the yPoints array. The last argument specifies the number of points. This method draws a closed polygon. If the last point is different from the first point, the polygon is closed by a line that connects the last point to the first point.

public void drawPolyline( int xPoints[], int yPoints[], int points )

Draws a sequence of connected lines. The x-coordinate of each point is specified in the xPoints array and the y-coordinate of each point is specified in the yPoints array. The last argument specifies the number of points. If the last point is different from the first point, the polyline is not closed.

public void drawPolygon( Polygon p )

Draws the specified polygon.

public void fillPolygon( int xPoints[], int yPoints[], int points )

Draws a solid polygon. The x-coordinate of each point is specified in the xPoints array and the y-coordinate of each point is specified in the yPointsarray. The last argument specifies the number of points. This method draws a closed polygon. If the last point is different from the first point, the polygon is closed by a line that connects the last point to the first point.

public void fillPolygon( Polygon p )

Draws the specified solid polygon. The polygon is closed.

Polygon constructors and methods

public Polygon()

Constructs a new polygon object. The polygon does not contain any points.

public Polygon( int xValues[], int yValues[], int numberOfPoints )

Constructs a new polygon object. The polygon has numberOfPoints sides, with each point consisting of an x-coordinate from xValues and a y-coordinate from yValues.

public void addPoint( int x, int y )

Adds pairs of x- and y-coordinates to the Polygon.

Fig. 12.20 Graphics methods for drawing polygons and class Polygon methods.

1 // Fig. 12.21: DrawPolygons.java2 // Drawing polygons.3 import java.awt.*;4 import javax.swing.*;

Fig. 12.21 Polygons displayed with drawPolygon and fillPolygon. (Part 1 of 3.)



56 public class DrawPolygons extends JFrame {78 // set window's title bar String and dimensions9 public DrawPolygons()

10 {11 super( "Drawing Polygons" );1213 setSize( 275, 230 );14 setVisible( true );15 }1617 // draw polygons and polylines18 public void paint( Graphics g )19 {20 super.paint( g ); // call superclass's paint method212223242526272829303132333435363738394041424344454647 } // end method paint4849 // execute application50 public static void main( String args[] )51 {52 DrawPolygons application = new DrawPolygons();53 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );54 }5556 } // end class DrawPolygons


int xValues[] = { 20, 40, 50, 30, 20, 15 }; int yValues[] = { 50, 50, 60, 80, 80, 60 }; Polygon polygon1 = new Polygon( xValues, yValues, 6 );

g.drawPolygon( polygon1 );

int xValues2[] = { 70, 90, 100, 80, 70, 65, 60 }; int yValues2[] = { 100, 100, 110, 110, 130, 110, 90 };

g.drawPolyline( xValues2, yValues2, 7 );

int xValues3[] = { 120, 140, 150, 190 };int yValues3[] = { 40, 70, 80, 60 };

g.fillPolygon( xValues3, yValues3, 4 );

Polygon polygon2 = new Polygon();polygon2.addPoint( 165, 135 ); polygon2.addPoint( 175, 150 ); polygon2.addPoint( 270, 200 ); polygon2.addPoint( 200, 220 ); polygon2.addPoint( 130, 180 );

g.fillPolygon( polygon2 );



Lines 22–23 create two int arrays and use them to specify the points for Polygonpolygon1. The Polygon constructor call at line 24 receives array xValues, which con-tains the x-coordinate of each point; array yValues, which contains the y-coordinate ofeach point and 6 (the number of points in the polygon). Line 26 displays polygon1 bypassing it as an argument to Graphics method drawPolygon.

Lines 28–29 create two int arrays and use them to specify the points for a series ofconnected lines. Array xValues2 contains the x-coordinate of each point and arrayyValues2 contains the y-coordinate of each point. Line 31 uses Graphics method draw-Polyline to display the series of connected lines specified with the arguments xValues2,yValues2 and 7 (the number of points).

Lines 33–34 create two int arrays and use them to specify the points of a polygon.Array xValues3 contains the x-coordinate of each point and array yValues3 contains they-coordinate of each point. Line 36 displays a polygon by passing to Graphics methodfillPolygon the two arrays (xValues3 and yValues3) and the number of points todraw (4).

Common Programming Error 12.2An ArrayIndexOutOfBoundsException is thrown if the number of points specified in thethird argument to method drawPolygon or method fillPolygon is greater than the num-ber of elements in the arrays of coordinates that specify the polygon to display. 12.2

Line 38 creates Polygon polygon2 with no points. Lines 39–43 use Polygonmethod addPoint to add pairs of x- and y-coordinates to the Polygon. Line 45 displaysPolygon polygon2 by passing it to Graphics method fillPolygon.

12.8 Java2D APIThe new Java2D API provides advanced two-dimensional graphics capabilities for pro-grammers who require detailed and complex graphical manipulations. The API includesfeatures for processing line art, text and images in packages java.awt, java.awt.im-age, java.awt.color, java.awt.font, java.awt.geom, java.awt.print andjava.awt.image.renderable. The capabilities of the API are far too broad to cover inthis textbook. For an overview of the capabilities, see the Java2D demo (demonstrated inChapter 3) or visit java.sun.com/products/java-media/2D/index.html. In thissection, we overview several Java2D capabilities.


Result of line 24

Result of line 31

Result of line 36

Result of line 45



Drawing with the Java2D API is accomplished with an instance of Graphics2D(package java.awt), which is an abstract subclass of class Graphics, so it has all thegraphics capabilities demonstrated earlier in this chapter. In fact, the actual object used todraw in every paint method is an instance of a subclass of Graphics2D that is passed tomethod paint and accessed via the superclass Graphics g. To access Graphics2D capa-bilities, we must cast the Graphics reference passed to paint into a Graphics2D refer-ence with a statement such as

Graphics2D g2d = ( Graphics2D ) g;

The next two examples use this technique.

Lines, Rectangles, Round Rectangles, Arcs and EllipsesThe next example demonstrates several Java2D shapes from package java.awt.geom, in-cluding Line2D.Double, Rectangle2D.Double, RoundRectangle2D.Double,Arc2D.Double and Ellipse2D.Double. Note the syntax of each class name. Each ofthese classes represents a shape with dimensions specified as double-precision floating-point values. There is a separate version of each represented with single-precision floating-point values (such as Ellipse2D.Float). In each case, Double is a static nested classof the class specified to the left of the dot (e.g., Ellipse2D). To use the static nestedclass, we simply qualify its name with the outer class name.

Figure 12.22 shows how to draw Java2D shapes and modify their drawing character-istics, such as changing line thickness, filling shapes with patterns and drawing dashedlines. These are just a few of the many capabilities provided by Java2D.

1 // Fig. 12.22: Shapes.java2 // Demonstrating some Java2D shapes.3 import java.awt.*;4 import java.awt.geom.*;5 import java.awt.image.*;6 import javax.swing.*;78 public class Shapes extends JFrame {9

10 // set window's title bar String and dimensions11 public Shapes() 12 {13 super( "Drawing 2D shapes" );1415 setSize( 425, 160 );16 setVisible( true );17 }1819 // draw shapes with Java2D API20 public void paint( Graphics g )21 {22 super.paint( g ); // call superclass's paint method23

Fig. 12.22 Java2D shapes. (Part 1 of 3.)



242526272829303132333435363738394041 gg.setColor( Color.YELLOW ); // draw in yellow 42 gg.fillRect( 0, 0, 10, 10 ); // draw a filled rectangle43 gg.setColor( Color.BLACK ); // draw in black 44 gg.drawRect( 1, 1, 6, 6 ); // draw a rectangle 45 gg.setColor( Color.BLUE ); // draw in blue 46 gg.fillRect( 1, 1, 3, 3 ); // draw a filled rectangle47 gg.setColor( Color.RED ); // draw in red 48 gg.fillRect( 4, 4, 3, 3 ); // draw a filled rectangle4950515253545556575859606162636465666768697071 } // end method paint7273 // execute application74 public static void main( String args[] )75 {76 Shapes application = new Shapes();


Graphics2D g2d = ( Graphics2D ) g; // cast g to Graphics2D

// draw 2D ellipse filled with a blue-yellow gradient g2d.setPaint( new GradientPaint( 5, 30, Color.BLUE, 35, 100,

Color.YELLOW, true ) ); g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );

// draw 2D rectangle in red g2d.setPaint( Color.RED ); g2d.setStroke( new BasicStroke( 10.0f ) ); g2d.draw( new Rectangle2D.Double( 80, 30, 65, 100 ) );

// draw 2D rounded rectangle with a buffered backgroundBufferedImage buffImage = new BufferedImage( 10, 10, BufferedImage.TYPE_INT_RGB );

Graphics2D gg = buffImage.createGraphics();

// paint buffImage onto the JFrame g2d.setPaint( new TexturePaint( buffImage,

new Rectangle( 10, 10 ) ) ); g2d.fill( new RoundRectangle2D.Double( 155, 30, 75, 100, 50, 50 ) );

// draw 2D pie-shaped arc in white g2d.setPaint( Color.WHITE ); g2d.setStroke( new BasicStroke( 6.0f ) ); g2d.draw( new Arc2D.Double( 240, 30, 75, 100, 0, 270, Arc2D.PIE ) );

// draw 2D lines in green and yellow g2d.setPaint( Color.GREEN ); g2d.draw( new Line2D.Double( 395, 30, 320, 150 ) );

float dashes[] = { 10 };

g2d.setPaint( Color.YELLOW ); g2d.setStroke( new BasicStroke( 4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 10, dashes, 0 ) ); g2d.draw( new Line2D.Double( 320, 30, 395, 150 ) );



Line 24 casts the Graphics reference received by paint to a Graphics2D referenceand assigns it to g2d to allow access to the Java2D features.

The first shape we draw is an oval filled with gradually changing colors. Lines 27–28invoke Graphics2D method setPaint to set the Paint object that determines the colorfor the shape to display. A Paint object is an object of any class that implements interfacejava.awt.Paint. The Paint object can be something as simple as one of the predeclaredColor objects introduced in Section 12.3 (class Color implements Paint), or the Paintobject can be an instance of the Java2D API’s GradientPaint, SystemColor or Tex-turePaint classes. In this case, we use a GradientPaint object.

Class GradientPaint helps draw a shape in gradually changing colors—called agradient. The GradientPaint constructor used here requires seven arguments. The firsttwo arguments specify the starting coordinate for the gradient. The third argument specifiesthe starting Color for the gradient. The fourth and fifth arguments specify the ending coor-dinate for the gradient. The sixth argument specifies the ending Color for the gradient. Thelast argument specifies whether the gradient is cyclic (true) or acyclic (false). The twosets of coordinates determine the direction of the gradient. Because the second coordinate(35, 100) is down and to the right of the first coordinate (5, 30), the gradient goes down andto the right at an angle. Because this gradient is cyclic (true), the color starts with blue,gradually becomes yellow, then gradually returns to blue. If the gradient is acyclic, thecolor transitions from the first color specified (e.g., blue) to the second color (e.g., yellow).

Line 29 uses Graphics2D method fill to draw a filled Shape object—an instanceof any class that implements interface Shape (package java.awt). In this case, we displayan instance of class Ellipse2D.Double. The Ellipse2D.Double constructor receivesfour arguments specifying the bounding rectangle for the ellipse to display.

Next we draw a red rectangle with a thick border. Line 32 uses setPaint to set thePaint object to Color.RED. Line 33 uses Graphics2D method setStroke to set thecharacteristics of the rectangle’s border (or the lines for any other shape). Method set-Stroke requires as its argument a Stroke object, which is an instance of any class thatimplements interface Stroke (package java.awt). In this case, we use an instance ofclass BasicStroke. Class BasicStroke provides several constructors to specify thewidth of the line, how the line ends (called the end caps), how lines join together (calledline joins) and the dash attributes of the line (if it is a dashed line). The constructor herespecifies that the line should be 10 pixels wide.

77 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );78 }7980 } // end class Shapes




Line 34 uses Graphics2D method draw to draw a Shape object—in this case, aninstance of class Rectangle2D.Double. The Rectangle2D.Double constructorreceives four arguments specifying the upper-left x-coordinate, upper-left y-coordinate,width and height of the rectangle.

Next we draw a rounded rectangle filled with a pattern created in a BufferedImage(package java.awt.image) object. Lines 37–38 create the BufferedImage object.Class BufferedImage can be used to produce images in color and gray scale. This partic-ular BufferedImage is 10 pixels wide and 10 pixels tall. The third constructor argumentBufferedImage.TYPE_INT_RGB indicates that the image is stored in color using theRGB color scheme.

To create the fill pattern for the rounded rectangle, we must first draw into the Buff-eredImage. Line 40 creates a Graphics2D object (with a call to BufferedImagemethod createGraphics) that can be used to draw into the BufferedImage. Lines 41–48 use methods setColor, fillRect and drawRect (discussed earlier in this chapter) tocreate the pattern.

Lines 51–52 set the Paint object to a new TexturePaint (package java.awt)object. A TexturePaint object uses the image stored in its associated BufferedImage(the first constructor argument) as the fill texture for a filled-in shape. The second argumentspecifies the Rectangle area from the BufferedImage that will be replicated through thetexture. In this case, the Rectangle is the same size as the BufferedImage. However, asmaller portion of the BufferedImage can be used.

Line 53 uses Graphics2D method fill to draw a filled Shape object—in this case,an instance of class RoundRectangle2D.Double. The constructor for classRoundRectangle2D.Double receives six arguments specifying the rectangle dimensionsand the arc width and arc height used to determine the rounding of the corners.

Next we draw a pie-shaped arc with a thick white line. Line 56 sets the Paint objectto Color.WHITE. Line 57 sets the Stroke object to a new BasicStroke for a line 6pixels wide. Line 58 uses Graphics2D method draw to draw a Shape object—in this case,an Arc2D.Double. The Arc2D.Double constructor’s first four arguments specifying theupper-left x-coordinate, upper-left y-coordinate, width and height of the bounding rectanglefor the arc. The fifth argument specifies the start angle. The sixth argument specifies the arcangle. The last argument specifies how the arc is closed. Constant Arc2D.PIE indicatesthat the arc is closed by drawing two lines. One line from the arc’s starting point to thecenter of the bounding rectangle and one line from the center of the bounding rectangle tothe ending point. Class Arc2D provides two other static constants for specifying how thearc is closed. Constant Arc2D.CHORD draws a line from the starting point to the endingpoint. Constant Arc2D.OPEN specifies that the arc should not be closed.

Finally, we draw two lines using Line2D objects—one solid and one dashed. Line 61sets the Paint object to Color.GREEN. Line 62 uses Graphics2D method draw to drawa Shape object—in this case, an instance of class Line2D.Double. The Line2D.Doubleconstructor’s arguments specify starting coordinates and ending coordinates of the line.

Line 64 declares a one-element float array containing the value 10. This array will beused to describe the dashes in the dashed line. In this case, each dash will be 10 pixels long.To create dashes of different lengths in a pattern, simply provide the lengths of each dash asan element in the array. Line 66 sets the Paint object to Color.YELLOW. Lines 67–68 setthe Stroke object to a new BasicStroke. The line will be 4 pixels wide and will have



rounded ends (BasicStroke.CAP_ROUND). If lines join together (as in a rectangle at thecorners), the joining of the lines will be rounded (BasicStroke.JOIN_ROUND). Thedashes argument specifies the dash lengths for the line. The last argument indicates thestarting index in the dashes array for the first dash in the pattern. Line 69 then draws a linewith the current Stroke.

General PathsNext we present a general path—a shape constructed from straight lines and complexcurves. A general path is represented with an object of class GeneralPath (package ja-va.awt.geom). Figure 12.23 demonstrates drawing a general path in the shape of a five-pointed star.

1 // Fig. 12.23: Shapes2.java2 // Demonstrating a general path.3 import java.awt.*;4 import java.awt.geom.*;5 import javax.swing.*;67 public class Shapes2 extends JFrame {89 // set window's title bar String, background color and dimensions

10 public Shapes2()11 {12 super( "Drawing 2D Shapes" );1314 getContentPane().setBackground( Color.WHITE );15 setSize( 400, 400 );16 setVisible( true );17 }1819 // draw general paths20 public void paint( Graphics g )21 {22 super.paint( g ); // call superclass's paint method2324252627 Graphics2D g2d = ( Graphics2D ) g;282930313233 // create the star--this does not draw the star34 for ( int count = 1; count < xPoints.length; count++ )35363738

Fig. 12.23 Java2D general paths. (Part 1 of 2.)

int xPoints[] = { 55, 67, 109, 73, 83, 55, 27, 37, 1, 43 };int yPoints[] = { 0, 36, 36, 54, 96, 72, 96, 54, 36, 36 };

GeneralPath star = new GeneralPath(); // create GeneralPath object

// set the initial coordinate of the General Pathstar.moveTo( xPoints[ 0 ], yPoints[ 0 ] );

star.lineTo( xPoints[ count ], yPoints[ count ] );

star.closePath(); // close the shape



Lines 24–25 declare two int arrays representing the x- and y-coordinates of the pointsin the star. Line 28 creates GeneralPath object star.

Line 31 uses GeneralPath method moveTo to specify the first point in the star. Thefor statement at lines 34–35 uses GeneralPath method lineTo to draw a line to the nextpoint in the star. Each new call to lineTo draws a line from the previous point to the cur-

394041 // rotate around origin and draw stars in random colors42 for ( int count = 1; count <= 20; count++ ) {434445 // set random drawing color46 g2d.setColor( new Color( ( int ) ( Math.random() * 256 ),47 ( int ) ( Math.random() * 256 ), 48 ( int ) ( Math.random() * 256 ) ) );495051 }5253 } // end method paint5455 // execute application56 public static void main( String args[] )57 {58 Shapes2 application = new Shapes2();59 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );60 }6162 } // end class Shapes2

Fig. 12.23 Java2D general paths. (Part 2 of 2.)

g2d.translate( 200, 200 ); // translate the origin to (200, 200)

g2d.rotate( Math.PI / 10.0 ); // rotate coordinate system

g2d.fill( star ); // draw filled star



rent point. Line 37 uses GeneralPath method closePath to draw a line from the lastpoint to the point specified in the last call to moveTo. This completes the general path.

Line 39 uses Graphics2D method translate to move the drawing origin to location(200, 200). All drawing operations now use location (200, 200) as (0, 0).

The for statement at lines 42–51 draws the star 20 times by rotating it around thenew origin point. Line 43 uses Graphics2D method rotate to rotate the next displayedshape. The argument specifies the rotation angle in radians (with 360° = 2π radians). Line50 uses Graphics2D method fill to draw a filled version of the star.

12.9 (Optional Case Study) Thinking About Objects: Designing Interfaces with the UMLIn Section 11.9, we incorporated event handling into our simulation by modifying the col-laboration diagram that deals with passengers entering and exiting the elevator. We includ-ed both event handling and inheritance in that diagram. The Elevator informs its Door ofthe Elevator’s arrival. This Door opens the arrival Floor’s Door by obtaining its handlethrough a Location object (which was included in the arrival event), and potentially twoPerson objects exit and enter the Elevator after both Doors open. We also discussed lis-tener interfaces. In this section, we represent our listener interface with the UML.

RealizationsThe UML expresses the relationship between a class and an interface through a realization.A class realizes, or implements, the behaviors of an interface. A class diagram can show arealization between classes and interfaces. Figure 12.24 models the realization betweenclass Person and interface DoorListener. The relationship between Person and Door-Listener appears similar to a generalization, except that the arrow expressing the relation-ship is dashed instead of solid. Note that the middle compartment in interfaceDoorListener is empty, because interfaces do not contain attributes. Lastly, note theword “JavaInterface” placed in guillemets (« ») located in the first compartment of inter-face DoorListener. This notation distinguishes interface DoorListener as a Java inter-face in our system. Items placed in guillemets are called stereotypes in the UML. Astereotype is an extension of the UML. In this case, the stereotype « JavaInterface » extendsthe UML so that we can model Java interfaces.2

Figure 12.25 shows the alternate way to represent the realization of class Person andinterface DoorListener in the UML. Figure 12.25 is the elided diagram of Fig. 12.24.The small circle represents the interface, and the solid line represents the realization. Byhiding its operations, we condense the interface, making it easier to read; however, in doingso, we sacrifice the information about its behaviors. When constructing an elided diagram,common practice is to place the information regarding any behavior in a separate dia-gram—for example, we place the full DoorListener interface in the class diagram ofFig. 12.28.

2. According to the UML specification version 1.4, interfaces do not have attributes. However, Javainterfaces can have attributes (in the form of static final fields). Through the Java CommunityProcess (JCP), the Java community is developing a mapping from UML to Java that includes the« JavaInterface » stereotype (Java Specification Request 26). For more information on the JCP,visit www.jcp.org.



Forward engineering from the UML to implemented Java code benefits from well-con-structed realization diagrams. When declaring any class, specify the realization betweenthat class and its interface—that class will “implement” the interface and override the inter-face’s methods. For example, we use Fig. 12.24 to begin constructing Person.java.Figure 12.26 shows the Java implementation for Fig. 12.24. Lines 6–8 and lines 14–15declare the attributes and operations of Person, including those required by interfaceDoorListener.

Fig. 12.24 Class diagram that models class Person realizing interface DoorListener.

Fig. 12.25 Elided class diagram that models class Person realizing interface DoorListener.

1 // Person.java2 // Generated from Fig. 11.243 public class Person implements DoorListener {45 // attributes6 private int ID;7 private boolean moving = true;8 private Location location;9

10 // constructor11 public Person() {}1213 // methods of DoorListener14 public void doorOpened( DoorEvent doorEvent ) {}15 public void doorClosed( DoorEvent doorEvent ) {}16 }

Fig. 12.26 Class Person is generated from Fig. 12.24 .

«JavaInterface»DoorListener

+ doorOpened( doorEvent : DoorEvent ) : void+ doorClosed( doorEvent : DoorEvent ) : void

Person

- ID : Integer- moving : Boolean = true- location : Location

+ doorOpened( ) : void+ doorClosed( ) : void

DoorListenerPerson

- ID : Integer- moving : Boolean = true- location : Location

+ doorOpened( ) : void+ doorClosed( ) : void



When a Door opens or closes, that Door invokes the appropriate method declared ininterface DoorListener, but only if the Person has registered with that Door to receiveDoorEvents. Finally, we present an elided model of the realizations in our elevator modelin Fig. 12.27. The elided diagram does not contain any interface methods (making the dia-gram easier to read). Therefore, we model the interfaces in Fig. 12.28, which shows allinterface methods. We model the realization of interface PersonMoveListener inSection 14.13. Refer to these diagrams when studying the elevator simulation implementa-tion in Appendices G, H and I.

According to Fig. 12.27, classes Door, Light, Bell and Button implement interfaceElevatorMoveListener. Class Elevator implements interfaces ButtonListener,DoorListener and BellListener. Class ElevatorShaft implements interfacesLightListener, ButtonListener and DoorListener. Lastly, class Person imple-ments interface DoorListener. We re-examine Fig. 12.27 in Appendix E when we begincoding our model.

In this section we showed how to represent interfaces and realizations with the UML.We also presented class diagrams showing the listener interfaces and their realizations forour elevator simulation. In Section 14.13, we model how the user interacts with our simu-lation.

Fig. 12.27 Class diagram that models realizations in the elevator model.

Light

ElevatorShaft

Bell

Elevator

Person

Door Button

ButtonListener DoorListener

ElevatorMoveListener

DoorListenerLightListener

ButtonListener DoorListener BellListener



SUMMARY• A coordinate system is a scheme for identifying every possible point on the screen.

• The upper-left corner of a GUI component has the coordinates (0, 0). A coordinate pair is com-posed of an x-coordinate (the horizontal coordinate) and a y-coordinate (the vertical coordinate).

• Coordinate units are measured in pixels. A pixel is a display monitor’s smallest unit of resolution.

• A graphics context enables drawing on the screen in Java. A Graphics object manages a graphicscontext by controlling how pixels are displayed.

Fig. 12.28 Class diagram for listener interfaces.

«JavaInterface»DoorListener

+ doorOpened( DoorEvent : doorEvent ) : void+ doorClosed( DoorEvent : doorEvent ) : void

«JavaInterface»BellListener

+ bellRang( BellEvent : bellEvent ) : void

«JavaInterface»ElevatorMoveListener

+ elevatorArrived( ElevatorMoveEvent : elevatorMoveEvent ) : void+ elevatorDeparted( ElevatorMoveEvent : elevatorMoveEvent ) : void

«JavaInterface»PersonMoveListener

+ personCreated( PersonMoveEvent : personMoveEvent ) : void+ personArrived( PersonMoveEvent : personMoveEvent ) : void+ personDeparted( PersonMoveEvent : personMoveEvent ) : void+ personPressedButton( PersonMoveEvent : personMoveEvent ) : void+ personEntered( PersonMoveEvent : personMoveEvent ) : void+ personExited( PersonMoveEvent : personMoveEvent ) : void

«JavaInterface»LightListener

+ lightTurnedOn( LightEvent : lightEvent ) : void+ lightTurnedOff( LightEvent : lightEvent ) : void

«JavaInterface»ButtonListener

+ buttonPressed( ButtonEvent : buttonEvent ) : void+ buttonReset( ButtonEvent : buttonEvent ) : void



• Graphics objects contain methods for drawing, font manipulation, color manipulation and so on.

• Method paint is normally called in response to an event, such as uncovering a window.

• Method repaint requests a call to Component method update as soon as possible to clear theComponent’s background of any previous drawing, then update calls paint directly.

• Class Color declares methods and constants for manipulating colors in a Java program.

• Java uses RGB colors in which the red, green and blue color components are integers in the rangefrom 0 to 255 or floating-point values in the range from 0.0 to 1.0.

• Color methods getRed, getGreen and getBlue return integer values from 0 to 255 representingthe amount of red, green and blue in a Color. Class Color provides 13 predeclared Color objects.

• Graphics method getColor returns a Color object representing the current drawing color.Graphics method setColor sets the current drawing color.

• Java provides class JColorChooser to display a dialog for selecting colors. JColorChoosermethod showDialog displays a color chooser dialog and returns the selected Color object.

• The default JColorChooser dialog allows you to select a color from a variety of color swatches.The HSB tab allows you to select a color based on hue, saturation and brightness. The RGB taballows you to select a color by using sliders for the red, green and blue components of the color.

• Component method setBackground changes the background color of a component.

• Class Font’s constructor takes three arguments—the font name, the font style and the font size.The font name is any font currently supported by the system. The font style is Font.PLAIN,Font.ITALIC or Font.BOLD. The font size is measured in points.

• Graphics method setFont sets the drawing font.

• Class FontMetrics declares several methods for obtaining font metrics. Graphics method get-FontMetrics with no arguments obtains the FontMetrics object for the current font. Graph-ics method getFontMetrics with a Font argument returns that Font’s FontMetrics object.

• Methods draw3DRect and fill3DRect take five arguments specifying the top-left corner of therectangle, the width and height of the rectangle and whether the rectangle is raised or lowered.

• Methods drawRoundRect and fillRoundRect draw rectangles with rounded corners. Their firsttwo arguments specify the upper-left corner, the third and fourth arguments specify the width andheight, and the last two arguments—arcWidth and arcHeight—determine the horizontal andvertical diameters of the arcs used to represent the corners.

• Methods drawOval and fillOval take the same arguments—the top-left coordinate and thewidth and the height of the bounding rectangle that contains the oval.

• Arcs sweep from a starting angle the number of degrees specified by their arc angle. The startingangle specifies where the arc begins and the arc angle specifies the total number of degrees throughwhich the arc sweeps. Arcs that sweep counterclockwise are measured in positive degrees and arcsthat sweep clockwise are measured in negative degrees.

• Methods drawArc and fillArc take the same arguments—the top-left coordinate, the width andthe height of the bounding rectangle that contains the arc and the startAngle and arcAnglethat specify the sweep of the arc.

• Polygons are closed multisided shapes composed of straight segments. Polylines are a sequenceof connected points.

• One version of Graphics method drawPolygon displays a Polygon object. Another version re-ceives an array containing the x-coordinate of each point, an array containing the y-coordinate ofeach point and the number of points in the polygon and displays the corresponding polygon.



• Graphics method drawPolyline displays a series of connected lines specified by its arguments(an array containing the x-coordinate of each point, an array containing the y-coordinate of eachpoint and the number of points).

• Polygon method addPoint adds pairs of x- and y-coordinates to a Polygon.

• The Java2D API provides advanced two-dimensional graphics capabilities for processing line art,text and images.

• To access the Graphics2D capabilities, downcast the Graphics reference passed to paint to aGraphics2D reference.

• Graphics2D method setPaint sets the Paint object that determines the color and texture forthe shape to display. The Paint object can be a Color or an instance of the Java2D API’s Gra-dientPaint, SystemColor or TexturePaint classes.

• Class GradientPaint draws a shape in a gradually changing color called a gradient.

• Graphics2D method fill draws a filled Shape object.

• The Ellipse2D.Double constructor receives four arguments specifying the bounding rectanglefor the ellipse to display.

• Graphics2D method setStroke sets the characteristics of the lines used to draw a shape.

• Graphics2D method draw draws a Shape object.

• The Rectangle2D.Double constructor receives four arguments specifying the upper-left x-co-ordinate, upper-left y-coordinate, width and height of the rectangle.

• Class BufferedImage can be used to produce images in color and gray scale.

• A TexturePaint object uses the image stored in its associated BufferedImage as the fill tex-ture for a filled-in shape.

• The RoundRectangle2D.Double constructor receives six arguments specifying the rectangle’sdimensions and the arc width and arc height used to determine the rounding of the corners.

• The Arc2D.Double constructor’s first four arguments specify the upper-left x-coordinate, upper-left y-coordinate, width and height of the bounding rectangle for the arc. The fifth argument spec-ifies the start angle. The sixth argument specifies the end angle. The last argument specifies thetype of arc (Arc2D.PIE, Arc2D.CHORD or Arc2D.OPEN).

• The Line2D.Double constructor’s arguments specify starting and ending line coordinates.

• A general path is a shape constructed from straight lines and complex curves represented with anobject of class GeneralPath (package java.awt.geom).

• GeneralPath method moveTo specifies the first point in a general path. GeneralPath methodlineTo draws a line to the next point in the general path. Each new call to lineTo draws a linefrom the previous point to the current point. GeneralPath method closePath draws a line fromthe last point to the point specified in the last call to moveTo.

• Graphics2D method translate moves the drawing origin to a new location. All drawing oper-ations now use that location as (0, 0). Graphics2D method rotate is used to rotate the next dis-played shape. Its argument specifies the rotation angle in radians (with 360° = 2π radians).

TERMINOLOGY addPoint method of Polygon arc widtharc Arc2D.Double classarc bounded by a rectangle ascentarc height background colorarc sweeping through an angle baseline



SELF-REVIEW EXERCISES12.1 Fill in the blanks in each of the following statements:

a) In Java2D, method of class sets the characteristics of a line usedto draw a shape.

bounding rectangle getRed method of ColorBufferedImage class getSize method of Fontclosed polygon getStyle method of FontclosePath method of GeneralPath GradientPaint classColor class Graphics classComponent class graphics contextcoordinate graphics objectcoordinate system Graphics2D classdegree isBold method of Fontdescent isItalic method of Fontdraw method isPlain method of Fontdraw3DRect method of Graphics Java2D APIdrawArc method of Graphics leadingdrawLine method of Graphics Line2D.Double classdrawOval method of Graphics lineTo method of GeneralPathdrawPolygon method of Graphics Monospaced fontdrawPolyline method of Graphics moveTo method of GeneralPathdrawRect method of Graphics negative degreesdrawRoundRect method of Graphics ovalEllipse2D.Double class Paint interfacefill method of Graphics2D pixelfill3DRect method of Graphics pointfillArc method of Graphics polygonfilled polygon Polygon classfillOval method of Graphics positive degreesfillPolygon method of Graphics Rectangle2D.Double classfillRect method of Graphics RGB valuefillRoundRect method of Graphics rotate method of Graphics2Dfont RoundRectangle2D.Double classFont class SansSerif fontfont metrics Serif fontfont name setColor method of Graphicsfont style setFont method of GraphicsFontMetrics class setPaint method of Graphics2DGeneralPath class setStroke method of Graphics2DgetAscent method of FontMetrics Shape interfacegetBlue method of Color Stroke interfacegetDescent method of FontMetrics SystemColor classgetFamily method of Font TexturePaint classgetFont method of Graphics translate method of Graphics2DgetFontMetrics method of Graphics vertical componentgetGreen method of Color x-axisgetHeight method of FontMetrics x-coordinategetLeading method of FontMetrics y-axisgetName method of Font y-coordinate



b) Class helps specify the fill for a shape such that the fill gradually changesfrom one color to another.

c) The method of class Graphics draws a line between two points.d) RGB is short for , and .e) Font sizes are measured in units called .f) Class helps specify the fill for a shape using a pattern drawn in a Buffered-

Image.

12.2 State whether each of the following is true or false. If false, explain why.a) The first two arguments of Graphics method drawOval specify the center coordinate of

the oval.b) In the Java coordinate system, x values increase from left to right.c) Method fillPolygon draws a solid polygon in the current color.d) Method drawArc allows negative angles.e) Method getSize returns the size of the current font in centimeters.f) Pixel coordinate (0, 0) is located at the exact center of the monitor.

12.3 Find the error(s) in each of the following and explain how to correct the error(s). Assume thatg is a Graphics object.

a) g.setFont( "SansSerif" ); b) g.erase( x, y, w, h ); // clear rectangle at (x, y)c) Font f = new Font( "Serif", Font.BOLDITALIC, 12 );d) g.setColor( Color.Yellow ); // change color to yellow

ANSWERS TO SELF-REVIEW EXERCISES12.1 a) setStroke, Graphics2D. b) GradientPaint. c) drawLine. d) red, green, blue.e) points. f) TexturePaint.

12.2 a) False. The first two arguments specify the upper-left corner of the bounding rectangle.b) True.c) True.d) True.e) False. Font sizes are measured in points.f) False. The coordinate (0,0) corresponds to the upper-left corner of a GUI component on

which drawing occurs.

12.3 a) The setFont method takes a Font object as an argument—not a String.b) The Graphics class does not have an erase method. The clearRect method should

be used.c) Font.BOLDITALIC is not a valid font style. To get a bold italic font, use Font.BOLD +

Font.ITALIC.d) Yellow should be all uppercase letters as in: g.setColor( Color.YELLOW );.

EXERCISES12.4 Fill in the blanks in each of the following statements:

a) Class of the Java2D API is used to draw ovals. b) Methods draw and fill of class Graphics2D require an object of type

as their argument.c) The three constants that specify font style are , and .d) Graphics2D method sets the painting color for Java2D shapes.



12.5 State whether each of the following is true or false. If false, explain why.a) The drawPolygon method automatically connects the endpoints of the polygon.b) The drawLine method draws a line between two points.c) The fillArc method uses degrees to specify the angle.d) In the Java coordinate system, y values increase from top to bottom.e) The Graphics class inherits directly from class Object.f) The Graphics class is an abstract class.g) The Font class inherits directly from class Graphics.

12.6 Write a program that draws a series of eight concentric circles. The circles should be sepa-rated by 10 pixels. Use the drawOval method of class Graphics.

12.7 Write a program that draws a series of eight concentric circles. The circles should be sepa-rated by 10 pixels. Use the drawArc method.

12.8 Modify your solution to Exercise 12.6 to draw the ovals by using instances of classEllipse2D.Double and method draw of class Graphics2D.

12.9 Write a program that draws lines of random lengths in random colors.

12.10 Modify your solution to Exercise 12.9 to draw random lines, in random colors and randomline thicknesses. Use class Line2D.Double and method draw of class Graphics2D to draw the lines.

12.11 Write a program that displays randomly generated triangles in different colors. Each triangleshould be filled with a different color. Use class GeneralPath and method fill of classGraphics2D to draw the triangles.

12.12 Write a program that randomly draws characters in different font sizes and colors.

12.13 Write a program that draws an 8-by-8 grid. Use the drawLine method.

12.14 Modify your solution to Exercise 12.13 to draw the grid using instances of classLine2D.Double and method draw of class Graphics2D.

12.15 Write a program that draws a 10-by-10 grid. Use the drawRect method.

12.16 Modify your solution to Exercise 12.15 to draw the grid by using instances of classRectangle2D.Double and method draw of class Graphics2D.

12.17 Write a program that draws a tetrahedron (a three-dimensional shape with four triangular fac-es). Use class GeneralPath and method draw of class Graphics2D.

12.18 Write a program that draws a cube. Use class GeneralPath and method draw of classGraphics2D.

12.19 In Exercise 3.10, you wrote an applet that input the radius of a circle from the user and dis-played the circle’s diameter, circumference and area. Modify your solution to Exercise 3.10 to read aset of coordinates in addition to the radius. Then draw the circle, and display the circle’s diameter,circumference and area, using an Ellipse2D.Double object to represent the circle and methoddraw of class Graphics2D to display the circle.

12.20 Write an application that simulates a screen saver. The application should randomly drawlines using method drawLine of class Graphics. After drawing 100 lines, the application shouldclear itself and start drawing lines again. To allow the program to draw continuously, place a call torepaint as the last line in method paint. Do you notice any problems with this on your system?

12.21 Here is a peek ahead. Package javax.swing contains a class called Timer that is capableof calling method actionPerformed of interface ActionListener at a fixed time interval (speci-fied in milliseconds). Modify your solution to Exercise 12.20 to remove the call to repaint frommethod paint. Declare your class so it implements ActionListener. (The actionPerformed



method should simply call repaint.) Declare an instance variable of type Timer called timer inyour class. In the constructor for your class, write the following statements:

timer = new Timer( 1000, this );timer.start();

This creates an instance of class Timer that will call this object’s actionPerformed methodevery 1000 milliseconds (i.e., every second).

12.22 Modify your solution to Exercise 12.21 to enable the user to enter the number of randomlines that should be drawn before the application clears itself and starts drawing lines again. Use aJTextField to obtain the value. The user should be able to type a new number into the JTextFieldat any time during the program’s execution. Use an inner class to perform event handling for theJTextField.

12.23 Modify your solution to Exercise 12.21 such that it uses random number generation tochoose different shapes to display. Use methods of class Graphics.

12.24 Modify your solution to Exercise 12.23 to use classes and drawing capabilities of the Java2DAPI. For shapes such as rectangles and ellipses, draw them with randomly generated gradients. Useclass GradientPaint to generate the gradient.

12.25 Modify your solution to Exercise 7.21—Turtle Graphics—to add a graphical user interfaceusing JTextFields and JButtons. Also, draw lines rather than drawing asterisks (*). When the tur-tle graphics program specifies a move, translate the number of positions into a number of pixels onthe screen by multiplying the number of positions by 10 (or any value you choose). Implement thedrawing with Java2D API features.

12.26 Produce a graphical version of the Knight’s Tour problem (Exercise 7.22, Exercise 7.23 andExercise 7.26). As each move is made, the appropriate cell of the chessboard should be updated withthe proper move number. If the result of the program is a full tour or a closed tour, the program shoulddisplay an appropriate message. If you would like, use class Timer (see Exercise 11.24) to help ani-mate the Knight’s Tour. Every second, the next move should be made.

12.27 Produce a graphical version of the Tortoise and the Hare simulation (Exercise 7.15). Simu-late the mountain by drawing an arc that extends from the bottom-left of the window to the top-rightof the window. The tortoise and the hare should race up the mountain. Implement the graphical outputso the tortoise and the hare are actually printed on the arc every move. [Note: Extend the length of therace from 70 to 300 to allow yourself a larger graphics area.]

12.28 Write a program that uses method drawPolyline to draw a spiral.

12.29 Write a program that inputs four numbers and graphs the numbers as a pie chart. Use classArc2D.Double and method fill of class Graphics2D to perform the drawing. Draw each piece ofthe pie in a separate color.

12.30 Write an applet that inputs four numbers and graphs the numbers as a bar graph. Use classRectangle2D.Double and method fill of class Graphics2D to perform the drawing. Draw eachbar in a different color.


objectives - pudn.comread.pudn.com/downloads57/sourcecode/windows/201021/deitel - java how... ·...

Documents