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.