Is this Overloading, methods with same name in dif

问题:

If I have the following code in Java:

class A {

    public int add(int a , int b) {
        return (a+b);
    }
}

class B extends A {
    public float add(float a , float b) {
        return (a+b);
}

In this particular case the sub-class isn't exactly overriding the base class's add function as they have different signatures and the concept of overloading occurs only if they are in the same scope. So, is the function add(float , float) in the sub-class B treated as an entirely new function and the concept of overloading and overriding is not applicable to it? And does it use 'Static binding' or 'Dynamic Binding'?

回答1:

Method add in class b is an overload of add in class a. Not an override. An override would just be a different implementation of the original add method.

回答2:

In brief, yes. To override, you need to replicate the complete method signature, which includes the method name, parameters and return types. From the tutorial

An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclass overrides the superclass's method.

You might want to consider the @Override annotation, which will trigger a compiler error if you don't successfully overrride a method.

In this particular instance, it perhaps looks like you don't need overriding so much as some solution including generics. So you could instantiate a class a<Integer> and a similar class a<Float>

回答3:

In that case you are not overriding the method, since the signatures are different.

But there is overloading in class b, since you have two methods with the same name but different parameters (one if class a, and the other one in class b)

Hope it helps.

回答4:

There can be a method that is not overridden but overloaded in the subclass. Here the subclass has two add() methods. The version which accepts int arguments(not overridden), and the overloaded method add() which accepts float arguments.

回答5:

I think in this particular case neither overloading nor overriding occurs, because return type must be same in case overloading and overriding, so neither static binding nor dynamic binding happens in this case. method overloading is not possible in case of different return type, because compiler can't figure that which method he need to call.

回答6:

I know it's late answer but i think it's important question need to be answered for beginners.

One key point in overloading is it works in inheritance.

Next is either it's Static binding or Dynamic binding.

It is Static Binding So, why?

Static Binding

1. Static binding in Java occurs during Compile time.
2. private, final and static methods and variables uses static binding and bonded by compiler.
3. Static binding uses Type (class in Java) information for binding.

Dynamic Binding

4. Dynamic binding occurs during Runtime.

5. Dynamic methods bonded during runtime based upon runtime object.

6. Dynamic binding uses Object to resolve binding.

But the important part is here

Overloaded methods are bonded using static binding while overridden methods are bonded using dynamic binding at runtime.

Java compiler determines correct version of the overloaded method to be executed at compile time based upon the type of argument used to call the method and parameters of the overloaded methods of both these classes receive the values of arguments used in call and executes the overloaded method.

B a=new B();
a.add(4, 5);
a.add(4.0f, 5.0f);

So if you will create reference of type B then it will search for proper argument type and for above code it will execute both methods.

A a=new B();
a.add(4, 5);
a.add(4.0f, 5.0f);

but for above code it will give compile time error for float arguments.

Hope it clears all doubts.

回答7:

The method add() in class A is also available to class B by inheritance, therefore the method is overloaded in class by changing the data type from int, int to float, float.

回答8:

The concept of Overloading comes in play if and only if the functions are in the same scope or class. cz if this is the case of method overloading then for same method signature or same argument type the compiler gets confuse and must give compile time error . but in the above program in class B if you pass the same argument in same order then according to overloading it must give error but it is not happening u can check it i already have. It is the case of inheritance where through object reference if you call any method then the compiler will check it in child class ,if its not there then it will look into parent class that the above program is all about. hope this is helpfull.