What are the advantages of overriding method in java class?

Answer 1

Any time you have a class that inherits a method from a superclass, you have the opportunity to override the method (unless, as you learned in the earlier chapters, the method is marked final). The key benefit of overriding is the ability to define behavior that's specific to a particular subclass type. The following example demonstrates a Porsche subclass of Car overriding the Car version of the drive() method:

public class Car {

public void drive() {

System.out.println("Generic Car Driving Generically");

}

}

class Porsche extends Car {

public void drive() {

System.out.println("Porsche driving Full Throttle");

}

}

For abstract methods you inherit from a superclass, you have no choice. You must implement the method in the subclass unless the subclass is also abstract. Abstract methods must be implemented by the concrete subclass, but this is a lot like saying that the concrete subclass overrides the abstract methods of the superclass. So you could think of abstract methods as methods you're forced to override.

The Car class creator might have decided that for the purposes of polymorphism, all Car subtypes should have an drive() method defined in a unique, specific way. Polymorphically, when someone has an Car reference that refers not to an Car instance, but to an Car subclass instance, the caller should be able to invoke drive() on the Car reference, but the actual runtime object (say, a Porsche instance) will run its own specific drive() method. Marking the drive() method abstract is the Car programmer's way of saying to all subclass developers, "It doesn't make any sense for your new subtype to use a generic drive() method, so you have to come up with your own drive() method implementation!" A (non-abstract), example of using polymorphism looks like this:

public class TestCars {

public static void main (String [] args) {

Car a = new Car();

Car b = new Porsche(); //Car ref, but a Porsche object

a.drive(); // Runs the Car version of drive()

b.drive(); // Runs the Porsche version of drive()

}

}

class Car {

public void drive() {

System.out.println("Generic Car Driveing Generically");

}

}

class Porsche extends Car {

public void drive() {

System.out.println("Porsche driving Full Throttle");

}

public void brake() { }

}

In the preceding code, the test class uses a Car reference to invoke a method on a Porsche object. Remember, the compiler will allow only methods in class Car to be invoked when using a reference to a Car. The following would not be legal given the preceding code:

Car c = new Porsche();

c.brake(); // Can't invoke brake();

// Car class doesn't have that method

To reiterate, the compiler looks only at the reference type, not the instance type. Polymorphism lets you use a more abstract supertype (including an interface) reference to refer to one of its subtypes (including interface implementers).

Answer 2

The advantage of overriding methods in Java is to allow those methods to handle multiple data types. This is significant in a few ways:

For the user of the method:

• The user will feel like their data is being handled in a more accurate way. If a method accepts an Object type, how that method will react when given an ArrayList or a Line2D object can be unclear. More specific types reduce confusion (and errors).
• The user will not have to convert their arguments before passing them in. For instance, if you have written a method that adds 5 numbers, and is overloaded to accept int and double parameters, the user will never have to convert their doubles to ints.

For the programmer of the method:

• The guesswork of exactly what type of data you are working with is taken out of the equation. For instance, if your method accepts a general Collection, you could be dealing with an ArrayList or a LinkedList, which can result in a huge difference in performance.
• The programmer can adapt the method to return different types of data. Math.abs() will return an int if passed in an int, and a double if passed in a double.

There are times however when overloading is unnecessary or even detrimental. For instance, it doesn't make sense to have a method that calculates P(n,r) (# permutations) accept floating point numbers.