Shulou(Shulou.com)06/02 Report--

This article will explain in detail what is the use of method overloading in JAVA. The editor thinks it is very practical, so I share it with you as a reference. I hope you can get something after reading this article.

In Java, two or more methods in the same class can have the same name, as long as their parameter declarations are different. In this case, the method is called overloaded, and this process is called method method overloading. Method overloading is a way for Java to achieve polymorphism. If you have never used a language that allows method overloading before, this concept may be a little strange at first. But as you'll see, method overloading is one of the most exciting and useful features of Java.

When an overloaded method is called, Java uses the type and / or number of parameters to indicate the version of the overloaded method that is actually called. Therefore, the type and / or number of parameters for each overloaded method must be different. Although each overloaded method can have a different return type, the return type is not sufficient to distinguish which method is used. When Java calls an overloaded method, the method whose parameters match the calling parameters is executed.

Here is a simple example that illustrates method overloading:

/ / Demonstrate method overloading.

Class OverloadDemo {

Void test () {

System.out.println ("No parameters")

}

/ / Overload test for one integer parameter.

Void test (int a) {

System.out.println ("a:" + a)

}

/ / Overload test for two integer parameters. Void test (int a drawing int b) {System.out.println ("an and b:" + a + "" + b);}

/ / overload test for a double parameter

Double test (double a) {

System.out.println ("double a:" + a)

Return aura;}}

Class Overload {

Public static void main (String args []) {

OverloadDemo ob = new OverloadDemo ()

Double result

/ / call all versions of test () ob.test (); ob.test (10); ob.test (10Power20); result = ob.test (123.25); System.out.println ("Result of ob.test (123.25):" + result)

}

}

The program produces the following output:

No parameters

A: 10

An and b: 10 20

Double a: 123.25

Result of ob.test (123.25): 15190.5625

As you can see from the above procedure, test () has been overloaded four times. The first version has no arguments, the second version has an integer parameter, the third version has two integer parameters, and the fourth version has a double parameter. Since overloading is not affected by the return type of the method, the fourth version of test () also returns a value that has no causal relationship with overloading.

When an overloaded method is called, Java looks for a match between the parameters of the calling method and the arguments of the method. However, this matching is not always accurate. In some cases, the automatic type conversion of Java also applies to the arguments of overloaded methods. For example, look at the following program:

/ / Automatic type conversions apply to overloading.

Class OverloadDemo {

Void test () {

System.out.println ("No parameters")

}

/ / Overload test for two integer parameters. Void test (int a drawing int b) {System.out.println ("an and b:" + a + "" + b);}

/ / overload test for a double parameter

Void test (double a) {

System.out.println ("Inside test (double) a:" + a)

}

}

Class Overload {

Public static void main (String args []) {

OverloadDemo ob = new OverloadDemo ()

Int I = 88

Ob.test (); ob.test (10pm 20)

Ob.test (I); / / this will invoke test (double)

Ob.test (123.2); / / this will invoke test (double)

}

}

The program produces the following output:

No parameters

An and b: 10 20

Inside test (double) a: 88

Inside test (double) a: 123.2

In this case, this version of OverloadDemo does not define test (int). So when test () is called with an integer argument within the Overload, no matching method is found. However, Java can automatically convert integers to double, and this conversion can solve this problem. Therefore, after test (int) is not found, Java expands I to double type and then calls test (double). Of course, if test (int) is defined, of course test (int) is called first instead of test (double). The automatic conversion of Java works only if an exact match is not found.

Method overloading supports polymorphism because it is a way for Java to implement the "one interface, multiple methods" paradigm. To understand this, consider the following passage: in languages that do not support method overloading, each method must have a unique name. However, you often want to implement different data types but essentially the same approach. You can refer to the example of an absolute value function. Languages that do not support overloading usually contain three or more versions of this function, each with a slightly different name. For example, in C, the function abs () returns the absolute value of an integer, labs () returns the absolute value of an integer of type long (), and fabs () returns the absolute value of a floating-point value. Although the functions of these three functions are essentially the same, because the C language does not support overloading, each function must have its own name. This makes the concept much more complicated. Although the underlying concept of each function is the same, you still have to remember these three names. This does not happen in Java because all absolute value functions can use the same name. Indeed, Java's standard class library contains an absolute value method called abs (). This method is overloaded by Java's math class and is used to handle numeric types. Java determines the version of abs () that is called based on the parameter type.

The value of overloading is that it allows related methods to be accessed using the same name. Therefore, the name abs stands for the general action it performs. Choosing the correct specified (specific) version for a particular environment is what the compiler does. As a programmer, you only need to remember the general operations performed. Through the application of polymorphism, several names are reduced to one. Although this example is quite simple, if you extend the concept, you will understand that overloading can help you solve more complex problems.

When you overload a method, each version of the method can perform any action you want. There is no rule that overloaded methods must be related to each other. However, in terms of style, method overloading implies a relationship. This is why you shouldn't do this when you can use methods that have nothing to do with overloading with the same name. For example, you can use the name sqr to create a method that returns the square of an integer and the square root of a floating-point value. But the two operations are functionally different. Applying the method in this way goes against its original intention. In actual programming, you should only overload operations that are closely related to each other.

7.1.1 Constructor overload

In addition to overloading normal methods, constructors can also be overloaded. In fact, for most of the real things you create

Class, overloaded constructors are common and are no exception. To understand why, let's recall the example of the Box class given in the previous chapter. Here is an example of the latest version of the Box class:

Class Box {double width; double height; double depth

/ / This is the constructor for Box.

Box (double w width double hre double d) {width = w; height = h position depth = d

}

/ / compute and return volume double volume () {return width * height * depth;}}

In this case, the Box () constructor requires three arguments, which means that all defined Box objects must pass three parameters to the Box () constructor. For example, the following statement is invalid in the current situation:

Box ob = new Box ()

Because Box () requires three parameters, it would be an error to call it without arguments. This will raise some important questions. What if you only want a box and don't care (or know) its original size? Or, what if you want to initialize a cube with just one value, and that value can be used for all three dimensions of it? If the Box class is written as it is now, you can't solve any other problem like this, because you can only take three parameters and have no other options.

Fortunately, the solution to these problems is fairly easy: overload the Box constructor so that it can handle the situation just described. The following program is an improved version of Box that uses overloading of the Box constructor to solve these problems:

/ * Here,Box defines three constructors to initialize

The dimensions of a box various ways.

, /

Class Box {

Double width; double height; double depth; / / constructor used when all dimensions specified Box (double w.redoublecomponent double d) {

Width = w

Height = h

Depth = d

}

/ / constructor used when no dimensions specified Box () {width =-1; / / use-1 to indicate

Height =-1; / / an uninitialized

Depth =-1; / / box

}

/ / constructor used when cube is created Box (double len) {width = height = depth = len;}

/ / compute and return volume double volume () {return width * height * depth;}}

Class OverloadCons {

Public static void main (String args []) {/ / create boxes using the various constructorsBox mybox1 = new Box; Box mybox2 = new Box (); Box mycube = new Box (7)

Double vol

/ / get volume of first box

Vol = mybox1.volume ()

System.out.println ("Volume of mybox1 is" + vol)

/ / get volume of second box

Vol = mybox2.volume ()

System.out.println ("Volume of mybox2 is" + vol)

/ / get volume of cube

Vol = mycube.volume ()

System.out.println ("Volume of mycube is" + vol)

}

}

The output produced by the program is as follows:

Volume of mybox1 is 3000.0

Volume of mybox2 is-1.0

Volume of mycube is 343.0

In this case, when the new executes, the appropriate constructor is called based on the specified argument.

This is the end of this article on "what is the use of method overloading in JAVA". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.