Initializing objects in Constructor

Question

I have below constructor, where it creates a workbook in constructor. I read that, ideally, we should not create objects in Constructor, instead, we should have just assignments which are passed.

public ExcelWriter() {
        workbook = new HSSFWorkbook();
        //other code
    }

Is it okay to create fixed objects like above? What is ideal alternative solution? and from Unit Testing perspective? If to pass workbook from calling method code in other class, we have to create the workbook object even there also.

Is later is better approach? How it is better or matters compared to constructor approach?

Answer 1

For beginning programmers this is fine.

However, like you said, if you want to unit test this ExcelWriter class, you could perhaps give the HSSFWorkbook object as an argument in the constructor rather than creating it yourself. This way, you can use the real one in your code, and use a mock in the unit tests. This practice is called dependency injection.

So your constructor would look like:

public ExcelWriter(HSSFWorkbook hssfWorkBook) {
    workbook = hssfWorkBook;
    // other code
}

Then, somewhere else in your code, you call that constructor:

HSSFWorkbook myWorkbook = new HSSFWorkbook();
ExcelWriter myExcelWriter = new ExcelWriter(myWorkbook);

And your unit test would be something like:

HSSFWorkbook myMockedWorkbook = // create a mock
ExcelWriter testWriter = new ExcelWriter(myMockedWorkbook);

If you want to do this even better, use interfaces, so you'll end up with two separate classes:

public interface IWorkbook {}

public class RealWorkbook implements IWorkbook {
    // this is the one for in your code
}

public class FakeWorkbook implements IWorkbook {
    // this is the one you use in your unit test
}

Answer 2

Nothing in the real world is ideal. But an alternate solution is called dependency injection:

public class ExcelWriter {
    Workbook workbook;
    public ExcelWriter(Workbook workbook) {
        this.workbook = workbook;
    }
    //other code
}

public void main(){        
    Writer writer = new ExcelWriter( new HSSFWorkbook() );       

    //other code
}

This way ExcelWriter can work with any kind of Workbook.

Answer 3

It breaks down to semantics.

If the instantiation is in the context of a wrapper to enhance functionality to a Workbook (Inheritance or Composition) then instantiating the Object within the constructor is fine. You would apply the rule "composition over inheritance".

If you compose Objects to create a disjunct new semantic then you should ask yourself if you want to be dependent on the concrete class as you have to know it to instantiate it.

If you have no problem with the concrete dependency (which may violate the dependency inversion principle) object instantiation in the constructor or lazy initialization are semantically identical. Lazy initialization only defers the instantiation until it is neccessary. You abstract from the point of time when an object is created.

If you may have multiple versions of a workbook under an abstraction you should prefer to pass the object in the constructor under this abstraction. On a high level object you should consider container functionality. There several possibilities of dependency injection technologies.

Answer 4

Use lazy initialization. Only create the workbook when someone needs it, e.g. the DoSomething method in this example:

public class ExcelWriter {
    Workbook workbook = null;
    public ExcelWriter() {
        //nop
    }

    protected Workbook getWorkbook() {
        if (workbook == null) workbook = new Workbook();
        return workbook;
    }

    public doSomething() {
        Workbook wb = getWorkbook();
    }
}