Java Inheritance Question

Question

Say I extend a class and override a method in this class. Why is it bad practice to then call the overridden method from the constructor of my new class?

why do you say it's bad practice? It probably depends on the circumstances... — jk., Jun 28 '11 at 20:05
Similar problem with C# http://stackoverflow.com/questions/119506/virtual-member-call-in-a-constructor — Bala R, Jun 28 '11 at 20:09
It just underlines it and days, "Overridable method call in constructor" as if it is warning me something bad is about to happen — user489041, Jun 28 '11 at 20:10
@user489041, Sorry if I have mentioned this before, but you have 34 questions without an accepted answer. — Peter Lawrey, Jun 28 '11 at 20:15

score 12 · Accepted Answer · answered Jun 28 '11 at 20:08

12

The main reason not to call overridable methods from constructors is that it allows subclasses to see the class in a half-constructed state. This may or may not be security risk, but it's a bug waiting to happen. Read more here.

answered Jun 28 '11 at 20:08

Rob Harrop

3,445
26
26

+1 for the link... finally something to read when I go to the beach! – SJuan76 Jun 28 '11 at 20:23

score 5 · Answer 2 · answered Jun 28 '11 at 20:05

5

It is generally a bad practice to do work in the constructor - just get and assign the object dependencies.

answered Jun 28 '11 at 20:05

Bozho

588,226
146
1,060
1,140

score 3 · Answer 3 · answered Jun 28 '11 at 20:07

3

Someone can inherit from your class and change the behavior that you are relying upon in your constructor.

This means that you do not know what you that function is going to do.

answered Jun 28 '11 at 20:07

sclarson

4,362
3
32
44

Feanor · Answer 4 · 2011-06-28T21:50:48.367

Because the resulting instance of the class could be in an inconsistent state. Here's a concrete example.

public class Foo {
    private int number;

    public Foo() {
        number = 42;
        multiplyNumber();
    }

    public void multiplyNumber() {
        number = number * 2;
    }

    public int getNumber() {
        return number;
    }
}

public class Bar extends Foo {

    private int number;

    public Bar() {
        multiplyNumber();
    }

    @Override
    public void multiplyNumber() {
        number = number * 3;
    }
}

public class FooBar {

    public static void main(String[] args) {
        Foo foo = new Foo();
        Foo bar = new Bar();
        System.out.println("Foo number 1 = " + foo.getNumber()); // Returns 84
        System.out.println("Foo number 2 = " + bar.getNumber()); // Returns 42; 
    }
}

When running through a debug on my machine, bar never actually calls the multiplyNumber() method in the constructor; it just gets skipped. As a result, the object doesn't have the expected value in number.

Constructors should be simple creatures; best not to put anything very complicated in there.

score 1 · Answer 5 · answered Jun 28 '11 at 20:28

Imagine that you call an overridable method in your constructor. you subclass again and override again. The second subclass can interrupt the work that your first subclass depends on to be deemed fully intialized thus leaving it in a corrupted state.

As for work in the constructor. You can do work, it just generally should be the type of work that is required to initialize your object.

For a best practice, avoid inheritance all together and if you decide to divide constructor work up into methods use visibility modifiers to ensure that all that work remains local to the class being constructed.

Java Inheritance Question

5 Answers5