AhmadLang / Java, How To Program, 2004

[Page 257 (continued)]

6.12. Method Overloading

Methods of the same name can be declared in the same class, as long as they have different sets of parameters (determined by the number, types and order of the parameters)this is called method overloading. When an overloaded method is called, the Java compiler selects the appropriate method by examining the number, types and order of the arguments in the call. Method overloading is commonly used to create several methods with the same name that perform the same or similar tasks, but on different types or different numbers of arguments. For example, Math methods abs, min and max (summarized in Section 6.3) are overloaded with four versions each:

[Page 258]

1.One with two double parameters.

2.One with two float parameters.

3.One with two int parameters.

4.One with two long parameters.

Our next example demonstrates declaring and invoking overloaded methods. You will see examples of overloaded constructors in Chapter 8.

Declaring Overloaded Methods

In our class MethodOverload (Fig. 6.13), we include two overloaded versions of a method called squareone that calculates the square of an int (and returns an int) and one that calculates the square

of a double (and returns a double). Although these methods have the same name and similar parameter lists and bodies, you can think of them simply as different methods. It may help to think of the method names as "square of int" and "square of double," respectively. When the application begins execution, class MethodOverloadTest's main method (Fig. 6.14, lines 610) creates an object of class MethodOverload (line 8) and calls the object's method testOverloadedMethods (line 9) to produce the program's output (Fig. 6.14).

Figure 6.13. Overloaded method declarations.

(This item is displayed on pages 258 - 259 in the print version)

1// Fig. 6.13: MethodOverload.java

2// Overloaded method declarations.

4public class MethodOverload

5{

6// test overloaded square methods

7public void testOverloadedMethods()

8{

9System.out.printf( "Square of integer 7 is %d\n", square( 7 ) );

13// square method with int argument

14public int square( int intValue )

15{

16System.out.printf( "\nCalled square with int argument: %d\n",

17intValue );

18return intValue * intValue;

19} // end method square with int argument

20

21// square method with double argument

22public double square( double doubleValue )

23{

24System.out.printf( "\nCalled square with double argument: %f\n",

25doubleValue );

26return doubleValue * doubleValue;

27} // end method square with double argument

28} // end class MethodOverload

Figure 6.14. Overloaded method declarations.

(This item is displayed on page 259 in the print version)

1// Fig. 6.14: MethodOverloadTest.java

2// Application to test class MethodOverload.

4public class MethodOverloadTest

5{

6public static void main( String args[] )

7{

8MethodOverload methodOverload = new MethodOverload();

9methodOverload.testOverloadedMethods();

10} // end main

11} // end class MethodOverloadTest

Called square with int argument: 7

Square of integer 7 is 49

Called square with double argument: 7.500000

Square of double 7.5 is 56.250000

[Page 259]

In Fig. 6.13, line 9 invokes method square with the argument 7. Literal integer values are treated as type int, so the method call on line 9 invokes the version of square at lines 1419 that specifies an int parameter. Similarly, line 10 invokes method square with the argument 7.5. Literal floating-point values are treated as type double, so the method call on line 10 invokes the version of square at lines 2227 that specifies a double parameter. Each method first outputs a line of text to prove that the proper method was called in each case. In line 10, note that the argument value and return value are displayed with the format specifier %f and that we did not specify a precision in either case. By default, floatingpoint values are displayed with six digits of precision if the precision is not specified in the format specifier.

Distinguishing Between Overloaded Methods

The compiler distinguishes overloaded methods by their signaturea combination of the method's name and the number, types and order of its parameters. If the compiler looked only at method names during compilation, the code in Fig. 6.13 would be ambiguousthe compiler would not know how to distinguish between the two square methods (lines 1419 and 2227). Internally, the compiler uses longer method names that include the original method name, the types of each parameter and the exact order of the parameters to determine whether the methods in a class are unique in that class.

[Page 260]

For example, in Fig. 6.13, the compiler might use the logical name "square of int" for the square method that specifies an int parameter and "square of double" for the square method that specifies a

double parameter (the actual names the compiler uses are messier). If method1's declaration begins as

void method1( int a, float b )

then the compiler might use the logical name "method1 of int and float." If the parameters are specified as

void method1( float a, int b )

then the compiler might use the logical name "method1 of float and int." Note that the order of the parameter types is importantthe compiler considers the preceding two method1 headers to be distinct.

Return Types of Overloaded Methods

In discussing the logical names of methods used by the compiler, we did not mention the return types of the methods. This is because method calls cannot be distinguished by return type. The program in Fig. 6.15 illustrates the compiler errors generated when two methods have the same signature and different return types. Overloaded methods can have different return types if the methods have different parameter lists. Also, overloaded methods need not have the same number of parameters.

Figure 6.15. Overloaded method declarations with identical signatures cause compilation errors, even if the return types are different.

1// Fig. 6.15: MethodOverloadError.java

2// Overloaded methods with identical signatures

5public class MethodOverloadError

6{

9{

10return x * x;

11}

12

13// second declaration of method square with int argument

14// causes compilation error even though return types are different

15public double square( int y )

16{

17return y * y;

18}

19} // end class MethodOverloadError

MethodOverloadError.java:15: square(int) is already defined in MethodOverloadError

public double square( int y )

^

1 error

[Page 261]

[Page 261 (continued)]

6.13. (Optional) GUI and Graphics Case Study: Colors and Filled Shapes

Although you can create many interesting designs with just lines and basic shapes, class Graphics provides many more capabilities. The next two features we introduce are colors and filled shapes. Adding color brings another dimension to the drawings a user sees on the computer screen. Filled shapes fill entire regions with solid colors, rather than just drawing outlines.

Colors displayed on computer screens are defined by their red, green, and blue components. These components, called RGB values, have integer values from 0 to 255. The higher the value of a particular component, the brighter the particular shade will be in the final color. Java uses class Color in package java.awt to represent colors using their RGB values. For convenience, the Color object contains 13 predefined static Color objectsColor.BLACK, Color.BLUE, Color.CYAN, Color.DARK_GRAY, Color.GRAY,

Color.GREEN, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE and Color.YELLOW. Class Color also contains a constructor of the form:

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

so you can create custom colors by specifying values for the individual red, green and blue components of a color.

Filled rectangles and filled ovals are drawn using Graphics methods fillRect and fillOval, respectively. These two methods have the same parameters as their unfilled counterparts drawRect and drawOval; the first two parameters are the coordinates for the upper-left corner of the shape, while the next two parameters determine its width and height. The example in Fig. 6.16 and Fig. 6.17 demonstrates colors and filled shapes by drawing and displaying a yellow smiley face on the screen.

Figure 6.16. Drawing a smiley face using colors and filled shapes.

(This item is displayed on page 262 in the print version)

1// Fig. 6.16: DrawSmiley.java

2// Demonstrates filled shapes.

3import java.awt.Color;

4import java.awt.Graphics;

5import javax.swing.JPanel;

6

7public class DrawSmiley extends JPanel

8{

9public void paintComponent( Graphics g )

10{

11super.paintComponent( g );

12

13// draw the face

14g.setColor( Color.YELLOW );

15g.fillOval( 10, 10, 200, 200 );

17// draw the eyes

18g.setColor( Color.BLACK );

19g.fillOval( 55, 65, 30, 30 );

20g.fillOval( 135, 65, 30, 30 );

22// draw the mouth

23g.fillOval( 50, 110, 120, 60 );

25// "touch up" the mouth into a smile

26g.setColor( Color.YELLOW );

27g.fillRect( 50, 110, 120, 30 );

28g.fillOval( 50, 120, 120, 40 );

29} // end method paintComponent

30} // end class DrawSmiley

Figure 6.17. Creating JFrame to display a smiley face.

5public class DrawSmileyTest

6{

7public static void main( String args[] )

8{

9DrawSmiley panel = new DrawSmiley();

10JFrame application = new JFrame();

12application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

13application.add( panel );

14application.setSize( 230, 250 );

15application.setVisible( true );

16} // end main

17} // end class DrawSmileyTest

The import statements in lines 35 of Fig. 6.16 import Color, Graphics and JPanel. Class DrawSmiley uses class Color to specify drawing colors and class Graphics to draw. Class JPanel again provides the area in which we draw. Line 14 in method paintComponent uses Graphics method setColor to set the current drawing color to Color.YELLOW. Method setColor requires one argument, the Color to set as the drawing color. In this case, we use the predefined object Color.YELLOW. Line 15 draws a circle with diameter 200 to represent the facewhen the width and height arguments are identical, method fillOval draws a circle. Next, line 18 sets the color to Color.Black, and lines 1920 draw the eyes. Line 23 draws the mouth as an oval, but this is not quite what we want. To create a happy face, we will "touch up" the mouth. Line 26 sets the color to Color.YELLOW, so any shapes we draw will blend in with the face. Line 27 draws a rectangle that is half the mouth's height. This "erases" the top half of the mouth, leaving just the bottom half. To create a better smile, line 28 draws another oval to slightly cover the upper portion of the mouth. Class DrawSmileyTest (Fig. 6.17) creates and displays a JFrame containing the drawing, resulting in the system calling method paintComponent to draw the smiley face.

[Page 263]

GUI and Graphics Case Study Exercises

6.1Using method fillOval, draw a bull's-eye that alternates between two random colors, as in Fig. 6.18. Use the constructor Color( int r, int g, int b ) with random arguments to generate random colors.

Figure 6.18. A bull's-eye with two alternating, random colors.