Re: catching exceptions in subclass' constructor?
On Tue, 2 Sep 2008, bugbear wrote:
My set of classes actually all represent formatting objects, which are
configured by (what might as well be) options, which are structured
strings (analogous to a command line in *NIX)
As such, each constructor normally performs a good deal of option
parsing and/or checking.
So my base class has a constructor which takes an option-string as a
parameter, and can throw (what I've called) a ParseExcepion.
But some of my subclasses (in practice) take no arguments. It was for
this set of subclasses that I was attempting to make an abstract
sub-class (for further subclassing) that takes no arguments, and (hence)
cannot throw an exception whilst parsing this lack-of-arguments.
I don't quite get this. Are the option strings different for each
subclass? If so, where does the parsing and processing happen? In the
subclass constructors? Or in the root class constructor? If the latter,
what gets passed to it in the subclasses which don't take arguments?
Some actual code, cut down if necessary, but actual code, would be great
here. If you could show us the root class, the class underneath it where
you wanted to add the exception handling, a leaf class which takes
parameters, and one which doesn't, that would be great.
An idea here might be to split the base class:
abstract class FormattingObject {
public FormattingObject() { // no exceptions
}
}
abstract class ConfiguredFormattingObject extends FormattingObject {
public ConfiguredFormattingObject(String conf) throws ParseException {
// parse conf here
}
}
class FooFormattingObject extends FormattingObject {
public FooFormattingObject() { // takes no params, throws no exception
super() ;
}
}
class BarFormattingObject extends ConfiguredFormattingObject {
public BarFormattingObject(String conf) throws ParseException {
super(conf) ;
}
}
tom
--
not to act in accordance with reason is contrary to God's nature --
Pope Benedict XVI