What s wrong with overridable method calls in constructors

Question

I have a Wicket page class that sets the page title depending on the result of an abstract method   public abstract class BasicPage extends WebPage        public BasicPage             add new Label  title   getTitle                 protected abstract String getTitle         NetBeans warns me with the message  Overridable method call in constructor   but what should be wrong with it  The only alternative I can imagine is to pass the results of otherwise abstract methods to the super constructor in subclasses  But that could be hard to read with many parameters

User · Answer

In the specific case of Wicket  This is the very reason why I asked the Wicket  devs to add support for an explicit two phase component initialization process in the framework s lifecycle of constructing a component i e     Construction - via constructor Initialization - via onInitilize  after construction when virtual methods work     There was quite an active debate about whether it was necessary or not  it fully  is necessary IMHO  as this link demonstrates http   apache-wicket 1842946 n4 nabble com VOTE-WICKET-3218-Component-onInitialize-is-broken-for-Pages-td3341090i20 html   The good news is that the excellent devs at Wicket did end up introducing two phase initialization  to make the most aweseome Java UI framework even more awesome   so with Wicket you can do all your post construction initialization in the onInitialize method that is called by the framework automatically if you override it - at this point in the lifecycle of your component its constructor has completed its work so virtual methods work as expected

User · Answer

Invoking an overridable method in the constructor allows subclasses to subvert the code  so you can t guarantee that it works anymore  That s why you get a warning   In your example  what happens if a subclass overrides getTitle   and returns null    To  fix  this  you can use a factory method instead of a constructor  it s a common pattern of objects instanciation

User · Answer

On invoking overridable method from constructors  Simply put  this is wrong because it unnecessarily opens up possibilities to MANY bugs  When the  Override is invoked  the state of the object may be inconsistent and or incomplete   A quote from Effective Java 2nd Edition  Item 17  Design and document for inheritance  or else prohibit it      There are a few more restrictions that a class must obey to allow inheritance  Constructors must not invoke overridable methods  directly or indirectly  If you violate this rule  program failure will result  The superclass constructor runs before the subclass constructor  so the overriding method in the subclass will be invoked before the subclass constructor has run  If the overriding method depends on any initialization performed by the subclass constructor  the method will not behave as expected    Here s an example to illustrate   public class ConstructorCallsOverride       public static void main String   args             abstract class Base               Base                     overrideMe                              abstract void overrideMe                        class Child extends Base                final int x               Child int x                    this x   x                              Override             void overrideMe                     System out println x                                   new Child 42      prints  0            Here  when Base constructor calls overrideMe  Child has not finished initializing the final int x  and the method gets the wrong value  This will almost certainly lead to bugs and errors   Related questions   Calling an Overridden Method from a Parent-Class Constructor State of Derived class object when Base class constructor calls overridden method in Java Using abstract init   function in abstract class   s constructor   See also   FindBugs - Uninitialized read of field method called from constructor of superclass      On object construction with many parameters  Constructors with many parameters can lead to poor readability  and better alternatives exist   Here s a quote from Effective Java 2nd Edition  Item 2  Consider a builder pattern when faced with many constructor parameters      Traditionally  programmers have used the telescoping constructor pattern  in which you provide a constructor with only the required parameters  another with a single optional parameters  a third with two optional parameters  and so on      The telescoping constructor pattern is essentially something like this   public class Telescope       final String name      final int levels      final boolean isAdjustable       public Telescope String name            this name  5             public Telescope String name  int levels            this name  levels  false             public Telescope String name  int levels  boolean isAdjustable                   this name   name          this levels   levels          this isAdjustable   isAdjustable            And now you can do any of the following   new Telescope  X 1999    new Telescope  X 1999   13   new Telescope  X 1999   13  true     You can t  however  currently set only the name and isAdjustable  and leaving levels at default  You can provide more constructor overloads  but obviously the number would explode as the number of parameters grow  and you may even have multiple boolean and int arguments  which would really make a mess out of things   As you can see  this isn t a pleasant pattern to write  and even less pleasant to use  What does  true  mean here  What s 13     Bloch recommends using a builder pattern  which would allow you to write something like this instead   Telescope telly   new Telescope Builder  X 1999   setAdjustable true  build      Note that now the parameters are named  and you can set them in any order you want  and you can skip the ones that you want to keep at default values  This is certainly much better than telescoping constructors  especially when there s a huge number of parameters that belong to many of the same types   See also   Wikipedia Builder pattern Effective Java 2nd Edition  Item 2  Consider a builder pattern when faced with many constructor parameters  excerpt online    Related questions   When would you use the Builder Pattern  Is this a well known design pattern  What is its name

User · Answer

I guess for Wicket it s better to call add method in the onInitialize    see components lifecycle     public abstract class BasicPage extends WebPage        public BasicPage                 Override     public void onInitialize             add new Label  title   getTitle                 protected abstract String getTitle

User · Answer

Here s an example which helps to understand this    public class Main       static abstract class A           abstract void foo            A                 System out println  Constructing A                foo                         static class C extends A           C                  System out println  Constructing C                      void foo                  System out println  Using C                          public static void main String   args            C c   new C               If you run this code  you get the following output    Constructing A Using C Constructing C   You see  foo   makes use of C before C s constructor has been run  If foo   requires C to have a defined state  i e  the constructor has finished   then it will encounter an undefined state in C and things might break  And since you can t know in A what the overwritten foo   expects  you get a warning

User · Answer

Here is an example that reveals the logical problems that can occur when calling an overridable method in the super constructor   class A        protected int minWeeklySalary      protected int maxWeeklySalary       protected static final int MIN   1000      protected static final int MAX   2000       public A             setSalaryRange               protected void setSalaryRange             throw new RuntimeException  not implemented               public void pr             System out println  minWeeklySalary      minWeeklySalary           System out println  maxWeeklySalary      maxWeeklySalary            class B extends A        private int factor   1       public B int  factor            this factor    factor              Override     protected void setSalaryRange             this minWeeklySalary   MIN   this factor          this maxWeeklySalary   MAX   this factor           public static void main String   args        B b   new B 2       b pr        The result would actually be   minWeeklySalary  0  maxWeeklySalary  0  This is because the constructor of class B first calls the constructor of class A  where the overridable method inside B gets executed  But inside the method we are using the instance variable factor which has not yet been initialized  because the constructor of A has not yet finished   thus factor is 0 and not 1 and definitely not 2  the thing that the programmer might think it will be   Imagine how hard would be to track an error if the calculation logic was ten times more twisted    I hope that would help someone

User · Answer

If you call methods in your constructor that subclasses override  it means you are less likely to be referencing variables that don   t exist yet if you divide your initialization logically between the constructor and the method   Have a look on this sample link http   www javapractices com topic TopicAction do Id 215

[java] What's wrong with overridable method calls in constructors?

Examples related to java

Examples related to oop

Examples related to inheritance

Examples related to constructor

Examples related to overriding