Abstract类的子类，总是调用Abstract构造函数

Question

I have an abstract class and a child class

abstract class abstractClass
{
    public int x;

    protected abstractClass(int x)
    {
        this.x = x;
    }
}

class childClass : abstractClass
{
    childClass(int x)
        : base(x)
    {
    }
}

I have many child classes like this one, where all of those classes always just call the common constructor abstractClass1(int x) by calling base(x) in their constructors.

When I want to add a new property to the constructor, for example another int y , I have to edit all of those classes and add the y as a parameter in every child's constructor plus the abstract class constructor.

Is there another way of doing this, considering I know beforehand that every child class will be using the abstract class constructor and won't be adding anything else ?

Answer 1

Here's one idea: make an AbstractClassParameters class:

class AbstractClassParameters {
    public int x { get; private set; }
    // add more parameters here
    public AbstractClassParameters(int x) {
        this.x = x;
        // add more initializers here
    }
}

Now you can pass an instance of AbstractClassParameters to the abstract class constructor, and every subclass can do the same, just passing it through.

abstract class abstractClass
{
    public int x;

    protected abstractClass(AbstractClassParameters p)
    {
        this.x = p.x;            
    }
}

class childClass : abstractClass
{
    childClass(AbstractClassParameters p) : base(p) { }
}

When you add a parameter, you only have to edit the AbstractClassParameters class and the abstractClass , not every subclass.

Answer 2

Unfortunately I don't think you can do it any other way. You have to modify abstract class because you have to add new member y. You either modify the abstract class constructor to initialize the member y or you can create a property around y and let children initialize it inside the constructor.

Answer 3

It seems to me that most of the already existing sub-classes can easily accept a default value for the new property y . In this case add a new constructor for the base class with the new property initializer, and have the old constructor set the value of the new property to the common default value. Now only the sub-classes that require a non-default value for the new property need to call the extended base-class constructor.

Your example becomes:

abstract class abstractClass
{
    public int x { get; private set; }
    public int y { get; private set; }

    protected abstractClass(int x) : this(x, defaultY) {}
    protected abstractClass(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

class childClass : abstractClass
{
    childClass(int x)
        : base(x)
    {
    }
}

class childClass2 : abstractClass
{
    childClass(int x, int y)
        : base(x,y)
    {
    }
}