Why is method overloading and overriding needed in java? [duplicate]

Answer 1

The answer primarily centers around the use of interfaces and abstract classes.

Let's say you have a block of code:

abstract class testAbstract {
    int a; int b; int c;
    public String testFunction() {
        System.out.println("Override me!");
        return "default";
    }

    public void setValuesByFormula(double a, double b) {
        System.out.println("No formula set!");
    }
}

This isn't the bet example, but let's say this is intended to allow the user to set a, b, and c from a formula. The user would like to create a new instance of this:

class testClass extends testAbstract {
}

The class testClass currently contains... nothing. But it extends testAbstract and thus has a function setValuesByFormula. When the user tries to call this, however, the system outputs the message: No formula set!

What the user must do at this point is @Override the original function. Thus, the new class becomes:

class testClass extends testInterface {
    public void setValuesByFormula(double a, double b) {
        //A not really relevant formula goes here.
    }
}

This stops the message No formula set! as the user has created their own formula. This is needed for a couple main reasons:

1. If a function is inherited from a superclass, often the child will want to override that function. However, the superclass may have default code for its class. Thus, the user must override this function if they wish to use their own code.
2. Often, superclasses want to ensure with default code that a certain function will return without error. There are also other instances where default code is helpful. Thus, this provides an alternative: if the user does not need the default code, they can override it.

Answer 2

Overriding

Java Docs says:

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.

The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed.

Overriding is a feature that is available while using Inheritance.

It is used when a class that extends from another class wants to use most of the feature of the parent class and wants to implement specific functionality in certain cases.

In such cases we can create methods with the same name and signature as in the parent class. This way the new method masks the parent method and would get invoked by default.

class Thought {
    public void message() {
        System.out.println("I feel like I am diagonally parked in a parallel universe.");
    }
}

public class Advice extends Thought {
    @Override  // @Override annotation in Java 5 is optional but helpful.
    public void message() {
        System.out.println("Warning: Dates in calendar are closer than they appear.");
    }
}

Overloading

Overloading in Java is the ability to create multiple methods of the same name, but with different parameters.

The main advantage of this is cleanliness of code.

Let's take the String.valueOf method. The overloaded versions of this method are defined as:

static String valueOf(boolean b) 
static String valueOf(char c) 
static String valueOf(char[] data) 
static String valueOf(char[] data, int offset, int count) 
static String valueOf(double d) 
static String valueOf(float f) 
static String valueOf(int i) 
static String valueOf(long l) 
static String valueOf(Object obj) 

This means that if we have any type of variable, we can get a String representation of it by using String.valueOf(variable).

If overloading was not allowed we'd have methods that look like this...

static String valueOfBoolean(boolean b) 
static String valueOfChar(char c) 
static String valueOfCharArray(char[] data) 
static String valueOfCharArrayWithOffset(char[] data, int offset, int count) 
static String valueOfDouble(double d) 
static String valueOfFloat(float f) 
static String valueOfInt(int i) 
static String valueOfLong(long l) 
static String valueOfObject(Object obj) 

...which is very ugly and harder to read than the overloaded solution.

Answer 3

From doc
Method Overloading: Suppose that you have a class that can use calligraphy to draw various types of data (strings, integers, and so on) and that contains a method for drawing each data type. It is cumbersome to use a new name for each method—for example, drawString, drawInteger, drawFloat, and so on. In the Java programming language, you can use the same name for all the drawing methods but pass a different argument list to each method. Thus, the data drawing class might declare four methods named draw, each of which has a different parameter list.

public class DataArtist {
    ...
    public void draw(String s) {
        ...
    }
    public void draw(int i) {
        ...
    }
    public void draw(double f) {
        ...
    }
    public void draw(int i, double f) {
        ...
    }
}

Overloaded methods are differentiated by the number and the type of the arguments passed into the method. In the code sample, draw(String s) and draw(int i) are distinct and unique methods because they require different argument types.

You cannot declare more than one method with the same name and the same number and type of arguments, because the compiler cannot tell them apart.

The compiler does not consider return type when differentiating methods, so you cannot declare two methods with the same signature even if they have a different return type.

Method overriding, in object oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. The implementation in the subclass overrides (replaces) the implementation in the superclass by providing a method that has same name, same parameters or signature, and same return type as the method in the parent class. The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed.