Ciao,

Ho una domanda relativamente all'estensione di classi. Vi faccio l'esempio del progetto su cui sto lavorando per cercare di spiegarmi:

Ho creato un'utility per l'esportazione dati in vari formati.
Per fare questo ho creato una classe astratta, DataExporter, che ha un metodo astratto dataBnd().
Ogni classe che estende DataExporter (per ora ho ExcelExporter, CsvExporter, SqlExporter) estende la classe ed implementa il metodo dataBind() secondo le esigenze del caso.

Ora, per non andare a modificare le classi che fruiscono di DataExporter, ho strutturato la classe in questo modo:

codice:
public abstract class DataExporter
{
	public enum ExportType
	{
	    EXCEL(1),
	    CSV(2),
	    SQL(3);
	    
	    private int value;
	    
	    private ExportType(int value)
	    {
	    	this.value = value;
	    }
	    
	    public int getValue()
	    {
	    	return value;
	    }
	}

	[...]

	public static Set<ExportSet> exportTypes()
        {
            Set<ExportSet> set = new TreeSet<ExportSet>();
        
            set.add(new ExportSet(ExportType.EXCEL, "Excel filesheet"));
            set.add(new ExportSet(ExportType.SQL, "SQL insert statement"));
            set.add(new ExportSet(ExportType.CSV, "CSV file ( ; )"));
        
            return set;
        }
    
        public static DataExporter getExporter(ExportSet eType) throws DataExporterException
        {
            DataExporter de = null;

            switch (eType.getExportType())
            {
                case CSV:

                    de = new CsvExporter();
                    break;

                case EXCEL:

                    de = new ExcelExporter();
                    break;

                case SQL:

                    de = new SqlExporter();
                    break;

                default:

                    throw new DataExporterException("Export type unknown.");
            }

            return de;
        }
...
Praticamente ho due metodi statici nella classe, uno che mi ritorna i "tipi" di export possibili, l'altro che mi ritorna un oggetto DataExporter istanziato con il costruttore del caso.

Ora, se volessi aggiungere ad esempio TxtExporter, oltre a creare la classe apposita che estende DataExporter, dovrei modificare anche DataExporter aggiungendo il nuovo tipo di esportazione ed il nuovo case nello switch che restituisce l'istanza.


Ciò che vi chiedo è se/come, secondo voi, è possibile impostare il lavoro in modo da non dover modificare, ad ogni estensione, la classe astratta.

Idee?

Ciao e grazie,

Alessandro.