How to extend a base member field?

Question

I have a class (Base) and a field of type InfoBase holding some information. A specialization (Ext) of Base needs to hold additional information (InfoExt). Therefore Ext assigns an InfoExt to Base.info. However I ran into problems when Base replaces info, since it would assign info = new InfoBase() hence the additional info of InfoExt is lost.

Therefore I created an abstract void assign() in Base (variant A). In this case info needs to be casted to InfoExt everytime it is used in Ext.

In variant B I have thus additionally created abstract InfoBase info().

                             variant A                        variant B
+----------------+  +---------------------------+  +----------------------------+
| InfoBase       |  | Base                      |  | Base'                      |
|----------------|  |---------------------------|  |----------------------------|
| + name: String |  | + info: InfoBase          |  | + abstract InfoBase info() |
|                |  | + abstract void assign()  |  | + abstract void assign()   |
|                |  |                           |  |                            |
+----------------+  +---------------------------+  +----------------------------+
          ^                      ^                               ^
          |                      |                               |
          +                      +                               +
+----------------+  +---------------------------+  +----------------------------+
| InfoExt        |  | Ext                       |  | Ext'                       |
|----------------|  |---------------------------|  |----------------------------|
| + id: int      |  | + void assign() {         |  | + InfoExt info             |
|                |  |     info = new InfoExt(); |  | + InfoBase info() {        |
|                |  |   }                       |  |     return info;           |
+----------------+  +---------------------------+  |   }                        |
                                                   | + void assign() {          |
                                                   |     info = new InfoExt();  |
                                                   |   }                        |
                                                   +----------------------------+

.

 class InfoBase {
   public String name;
 }

 abstract class Base {
    abstract public void assign();
    abstract InfoBase info();
 }


 class InfoExt extends InfoBase {
   public int id;
 }

 class Ext extends Base {
    public InfoExt info;

    @Override InfoBase info() { return info; }

    @Override public void assign() { info = new InfoExt(); }
 }

Is this a common situation with a generic way how to deal with it? Are there any drawbacks to variant A/B?

How can I provide an info field in Base, that subclasses can use to store extended information?

Thank you for your consideration

Answer 1

Perhaps something like this is what you are looking for?

abstract class Base {
    private InfoBase info; 

    abstract public void assign();

    protected void setInfo(InfoBase info) {
        this.info = info;
    }

    public InfoBase getInfo() { 
        return info;
    }
}

class Ext extends Base {
    private InfoExt info;

    @Override 
    public InfoExt getInfo() { 
        return info;
    }

    @Override
    public void assign() {
        info = new InfoExt();
        setInfo(info);
    }

}

This will allow Base to serve InfoBase objects, while Ext can serve InfoExt.