Overridding abstract methods

[Michael Carlson]

why would you want an abstract method of a subclass to override an abstract method of the superclass?
Thank you

[Christophe Verré]

To prevent the superclass's method from behind called ? (if the abstract method contains some implementation)

[Jay Pawar]

Originally posted by Satou kurinosuke:
To prevent the superclass's method from behind called ? (if the abstract method contains some implementation)

Abstract methods cannot have implementation.

[Christophe Verré]

Sorry, I meant a method in an abstract class. Got confused

[Hamid Virani]

I can think only one thing which can be achieved by doing this i.e.

making a protected abstract method in super class, a public abstract method
E.g.:

 
abstract class Abstr {
protected abstract void abc();
}
 
abstract class AbstrSubc extends Abstr {
public abstract void abc();
}

[Tia Ko]

Yup, one can do the following:
a) Increase the accessibility of the method
b) Reduce the number of exception thrown

[Lakhdeep Singh]

firstly i want to tell u what r abstract methods--which have no body.
Basically we use abstract methods to hide the implementation from the classes which have their prototypes. Overriding of abstract method is compulsary if u dont want 2 make sub class as an abstract & want to give the body 2 abstract method , otherwise it's not necessary at all.

Thank you

[Timothy E. Hay]

There are three main reasons:

1) To ensure that for subsubclasses which eventually implement the method, the return type is narrowed to a subclass of the return type specified by the superclass.
eg:

class Fruit {}
class Banana extends Fruit {}
class SmallBanana extends Banana {}
 
abstract class ClassA
{
    abstract Fruit getFruit();
}
 
abstract class ClassB extends ClassA
{
    // Cannot return a Fruit,
    // must return a Banana
    // or subclass of Banana
    abstract Banana getFruit();  
}
 
class ClassC extends ClassB
{
    Banana getFruit() { return new Banana(); }
}
 
class ClassD extends ClassB
{
    Banana getFruit() { return new SmallBanana(); }
}
 
class ClassE extends ClassB
{
    Banana getFruit() { return new Fruit(); } // Will not compile.
}
 
class ClassF extends ClassB
{
    Fruit getFruit() { return new Fruit(); }  // Will not compile
                                              //(not a valid overload).
}
class ClassE extends ClassB
{
    Fruit getFruit() { return new Fruit(); }  // Will not compile (go on, try it!)
}

2) As already mentioned by Tia, to reduce the number of exceptions thrown by classes derived from the subclass, BUT ALSO to restrict the exceptions thrown by these classes' implementation to subclasses of the Exceptions declared in abstract method declaration in the superclass.

3) As already mentioned by Hamid and Tia, to increase the accessibility of the method in classes derived from the subclass - ie: from default or protected to coderanch.

Cheers,

Tim