Any way to _not_ call superclass constructor in Java?

Question

If I have a class:

class A {    public A() { } } 

and another

class B extends A {    public B() { } } 

is there any way to get B.B() not to call A.A()?

Answer 1

There is absolutely no way to do this in Java; it would break the language specification.

JLS 12 Execution / 12.5 Creation of New Class Instances

Just before a reference to the newly created object is returned as the result, the indicated constructor is processed to initialize the new object using the following procedure:

1. Assign the arguments for the constructor [...]
2. If this constructor begins with an explicit constructor invocation of another constructor in the same class (using this), then [...]
3. This constructor does not begin with an explicit constructor invocation of another constructor in the same class (using this). If this constructor is for a class other than Object, then this constructor will begin with an explicit or implicit invocation of a superclass constructor (using super).
4. Execute the instance initializers and instance variable initializers for this class [...]
5. Execute the rest of the body of this constructor [...]

Answer 2

The closest you can achieve to the desired behaviour is to delegate initialisation normally performed in the constructor to a template method, which you then override in your subclass implementation. For example:

public class A {   protected Writer writer;    public A() {     init();   }    protected void init() {     writer = new FileWriter(new File("foo.txt"));   } }  public class B extends A {   protected void init() {     writer = new PaperbackWriter();   } } 

However, as other people have noted this can typically indicate a problem with your design and I typically prefer the composition approach in this scenario; for example in the above code you could define the constructor to accept a Writer implementation as a parameter.