When NOT to call super() method when overriding?

android, java, overriding

Solution

By calling the `super` method, you're not overriding the behavior of the method, you're extending it.

A call to `super` will perform any logic the class you're extending has defined for that method. Take into account that it might be important the moment when you call `super`'s implementation in your method overriding. For instance:

public class A { 
    public void save() { 
         // Perform save logic
    }
}

public class B extends A {
    private Object b;
    @Override
    public void save() { 
        super.save(); // Performs the save logic for A
        save(b); // Perform additional save logic
    }
}

A call to `B.save()` will perform the `save()` logic for both `A` and `B`, in this particular order. If you weren't calling `super.save()` inside `B.save()`, `A.save()` wouldn't be called. And if you called `super.save()` after `save(b)`, `A.save()` would be effectively performed afterwards `B.save()`.

If you want to override `super`'s behavior (that is, fully ignore its implementation and provide it all yourself), you shouldn't be calling `super`.

In the `SAXParser` example you provide, the implementations of `DefaultHandler` for those methods are just empty, so that subclasses can override them and provide a behavior for those methods. In the javadoc for this method this is also pointed out.

public void startElement (String uri, String localName,
    String qName, Attributes attributes) throws SAXException {
    // no op
}

About the `super()` default call in code generated by IDEs, as `@barsju` pointed out in his comment, in each constructor there's an implicit call to `super()` (even if you don't write it in your code), which means, in that context, a call to `super`'s default constructor. The `IDE` just writes it down for you, but it would also get called if you removed it. Also notice that when implementing constructors, `super()` or any of its variants with arguments (i.e. `super(x,y,z)`) can only be called at the very beginning of the method.

Problem

When I make my own Android custom class, I `extend` its native class. Then when I want to override the base method, I always call `super()` method, just like I always do in `onCreate`, `onStop`, etc. And I thought this is it, as from the very beginning Android team advised us to always call `super` on every method override. But, in many books I can see that developers, more experienced than myself, often omit calling `super` and I really doubt they do it as a lack of knowledge. For example, look at this basic SAX parser class where `super` is omitted in `startElement`, `characters` and `endElement`: ``` public class SAXParser extends DefaultHandler{ public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { if(qName.equalsIgnoreCase("XXY")) { //do something } } public void characters(char[] ch, int start, int length) throws SAXException { //do something } public void endElement(String uri, String localName, String qName) throws SAXException { if(qName.equalsIgnoreCase("XXY")) { //do something }else () { //do something } } } ``` If you try to create any override method via Eclipse or any other IDE, `super` will always be created as a part of automated process. This was just a simple example. Books are full of similar code. How do they know when you must call `super` and when you can omit it calling? PS. Do not bind to this specific example. It was just an example randomly picked from many examples. (This may sound like a beginner question, but I am really confused.)

Original source