How to determine the most matching method in Java function overloading mechanism?

Java function overload matching rules are: Exact match: Parameter type and number exactly match variable parameters: Variable parameter method matches any number or type of parameters Packaging type and original type conversion: Basic type and packaging type can be mutually exclusive Conversion autoboxing/unboxing: base type values ​​and wrapped type objects can be automatically converted to derived class types: derived class objects can match base class type parameters

Java Matching rules for the function overloading mechanism

Function overloading allows the creation of multiple methods with the same name but different parameter types in the same class. When an overloaded method is called, the JVM determines the best matching method to call based on the argument list.

Determination rules for the best match

1. Exact Match: If there is any parameter list of a method that is different from the call If the type and number of parameters match exactly, the method is the best matching method.

class Example {
    public void method(int a) {
        // ...
    }

    public void method(int a, int b) {
        // ...
    }
}

Calling method(1) will match method(int a).

2. Conform to variable parameters (Varargs): If a method is declared as a variable parameter, the method can be used with any number or type (including primitive types and objects) Parameters match. Variadic methods must be declared as the last method.

class Example {
    public void method(Object... args) {
        // ...
    }

    public void method(int a, int b) {
        // ...
    }
}

Calling method(1) or method(1, 2, "Hello") will match method(Object... args ).

3. Conversion between wrapped types and primitive types: Wrapping types of basic types (such as Integer) and corresponding primitive types (such as int) can be converted to each other. If there is a method that matches a raw type parameter but is called with a wrapped type parameter, or vice versa, the method can still be considered a match.

class Example {
    public void method(int a) {
        // ...
    }

    public void method(Integer a) {
        // ...
    }
}

Calling method(1) or method(new Integer(1)) can match these two methods.

4. Autoboxing and unboxing: When a basic type value is passed to a wrapper type parameter, it will be automatically boxed into a wrapper type object. When a wrapped type object is passed to a basic type parameter, it is automatically unboxed into a basic type value.

class Example {
    public void method(int a) {
        // ...
    }

    public void method(Integer a) {
        // ...
    }
}

Calling method(1) or method(Integer.valueOf(1)) can match these two methods.

5. Derived class type: When calling a parameter that uses a derived class object, the parameter can also match the parameter of its base class type.

class Animal {
    public void makeSound() {
        // ...
    }
}

class Dog extends Animal {
    public void makeSound() {
        // ...
    }
}

Calling makeSound(new Dog()) will also match the makeSound(Animal a) method.

Practical case

Suppose there is a Shape class, which has the following methods:

public class Shape {
    public void draw() {
        // ...
    }

    public void draw(int size) {
        // ...
    }

    public void draw(int size, boolean fill) {
        // ...
    }
}

When calling Shape shape = new Shape(); shape.draw(5);, the JVM will determine that the most matching method is draw(int size). This is because the size parameter was provided in the call but not the fill parameter, so draw(int size, boolean fill) is not an exact match.

The above is the detailed content of How to determine the most matching method in Java function overloading mechanism?. For more information, please follow other related articles on the PHP Chinese website!