A Closer Look at Methods and Classes
This chapter continues the-discussion of methods and classes begun in the ?receding chapter. It examines several topics relating to methods, including. overloading, parameter passing, and recursion. The chapter, then returns to the class, discussing-access control, the use of the keyword static, and one of Java's most important built-in classes: String,
In java is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case, the methods are said to be overloaded,' and the process is referred to as method over loading. Method overloading is 'one of the ways that Java implements
polymorphic m. If you have never used a language that allows the overloading of, methods, then the concept may seem strange at first. But as you will see, method over lousing most exciting arid useful features. When an overloaded method is Invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call. Thus-overloaded methods must differ in the type and/or number of their parameters ..While overloaded methods may'have different return.types; the return ' type alone is insufficient to distinguish two versions of a method. When,Java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call. Here is a-simple example that illustrates method overloading .
As you can see, test( ) is overloaded four times. The first version takes 'no parameters. the second takes one integer parameter, the third takes two integer parameters, and the fourth takes one double parameter. The fact that the fourth version of test( ) also returns a value is of no consequence relative to overloading, since return types do not player. role in overload resolution. I When an over loaded method is called, Java loo ks for a match between the arguments used to call the method and the method's parameters. However, this match need not always be exact. In some cases Java's automatic type conversions can player role in overload resolution. for example, consider the following program.
As you can see, this version of Over does not define lest(int). Therefore,when test( ) is called with an integer argument inside Overload, no matching method Is found.However, Java Call automatically convert an integer into a double, and this conversion can be used to resolve the call. Therefore; after test(int) is not found, Java elevates i to double and then-calls test double), Of course, if test(int) had been defined .
it would have been called instead. Java will employ its automatic type conversions only if no exact match is found. Method overloading supports polymorphic because it is one way that Java ,implements, the "one interface, multiple methods" paradigm. To understand how consider the following; In languages that do not support method overloading, each .method must be given a unique name. However, frequently you will want to implement essentially the same method for different types of data. Consider .the absolute value function. In languages that do not support overloading, there are usually-three or more versions of this function, each with a slightly different name. For Instance, in C, the function abs( ) returns the absolute value of an integer, labs( ) returns the absolute value of a long integer, and fast ) returns the absolute value of a floating-pollutant. Since C does not support overloading, each function has to hare its own name, overwrought all three functions do essentially the same thing. This makes the situation more complex, conceptually, than it actually is. 'Although the 'underlying~ concept of 'each function is the same, you still have three names to .remember. This situation 'does not occur in Java, because each absolute value method can use the same name. Indeed, Java's standard class library includes an absolute value method, called abs(). This method is overloaded by Java's Math class to handle numeric types. Java determines which version ,of abs() to call based upon the type of argument.
The value of overloading is that it allows related methods to be accessed by use of a
common name. Thus, the name abs represents the genera) action which is being performed. It is left to the compiler to choose the right specific version for a particular , circumstance. You, the programmer, need only remember the general operation being performed. Through the application of polymorphic, several ~lames have reduced to one. Although this example is simple, if you expand the concept/you , can see how overloading can help you manage greater complexity. When you overload a meted, each version of that method can perform any activity you desire. There is no rule stating that overloaded methods must relate one another. However, from a stylistic Pollux of view. method overloading implies a
relationship. Thus, while you can use the.same name to overload unrelated methods
you should not. For example, you could use the name sqr to create methods that return 'J the square of an integer and. the of a floating-point value, But these two operations are fundamentally different. Applying method overloading in this manner defeats its original purpose. In practice, you should only overload closely related operations.