Question

Is it possible to call an abstract constructor in one method, then pass that to some other methods, which would each cast the new object into specific subclasses? That is,

public AbstractClass createNewAbstractClass() {
    //do lots of checks that are the same for each sub class,
    //including geting and checking each variable,
    //and an exception thrown by the constructor.
    AbstractClass abstractClassObject = new AbstractClass(var1, ...);
    return abstractClassObject;
}

public SubClassOne createSubClassOneObject() {
    SubClassOne subClassOneObject = (SubClassOne)createNewAbstractClass(var1,..);
    return subClassOneObject;
}

public SubClassTwo createSubClassTwoObject() { ...

One way to get round this would be to get and check all the variables in one method, then return them in an array, so that the method createSubClassNObject() could use them in the right constructor, but that seems quite messy, and it would mean that each create method would have to check for the same exception in the same way and do the same thing about it, which sounds like exactly the situation you should try to outsource to another method!

I’m interested from a practical point of view – I want my code to be neat and readable – but also from a theoretical point of view – is this actually possible? So even if the answer is no, can you explain why?

Answer 1

There are a couple problems with this:

• Abstract classes can’t be instantiated; a constructor of an abstract class can only be called in a constructor of a subclass.
• Even if the parent class wasn’t abstract, the (SubClassOne) cast would fail because we would really have an instance of type AbstractClass, not an instance of type SubClassOne being typed as AbstractClass.

So unfortunately, the method which returns a SubClassOne will need to call a SubClassOne constructor, which might take the same parameters as AbstractClass and just delegate with a super call.

I don’t think there’s any easy way around duplicating some exception-handling code in each your factory methods; constructors don’t play well with polymorphism. You could have a central constructor which returns AbstractClass, but it would need a parameter (an enum, a Class, whatever) to tell it which subclass constructor to call.

abstract class Cow {
  Cow() throws Exception {
    ... // possible exceptions
  }
}

class FatCow extends Cow {
  FatCow() throws Exception {
    super();
    ...
  }
}

class GreenCow extends Cow {
  GreenCow() throws Exception {
    super();
    ...
  }
}

enum CowType {
  FAT_COW, GREEN_COW;
}

class CowMachine {
  static Cow makeCow(CowType type) {
    try {
      switch (type) {
        case FAT_COW:
          return new FatCow();
        case GREEN_COW:
          return new GreenCow();
        default:
          throw new IllegalArgumentException();
      }
    } catch (Exception e) {
      ...
      return null;
    }
  }

  static Cow makeFatCow() {
    return (FatCow) makeCow(CowType.FAT_COW);
  }

  static Cow makeGreenCow() {
    return (GreenCow) makeCow(CowType.GREEN_COW);
  }
}

If you don’t want a big swtich statement, you could instead accept a Class object and call newInstance, although this would be slower.