Creation of a universal (generic?) class i java

Question

I have four similar classes which only differ in type of created object inside them.
Like this

public class ImportingWarehouseP //ImportWarehouseW, ImportDictionary, ImportSupplier
{
    private ArrayList<WarehouseP> list = new ArrayList<WarehouseP>();

    public void importWarehouseP(File fileName) throws FileNotFoundException
    {
        FileReader in = new FileReader(fileName);
        Scanner src = new Scanner(in);
        src.useDelimiter("\n");
        src.next();
        for (int g = 0; src.hasNext(); g++) 
        {           
            String record = src.next();
            String [] asdf = record.trim().split(";|:");
            WarehouseP ob = new WarehouseP (asdf);  //here is the difference instead WarehouseP  can be WarehouseW, Dictionary, Supplier

            list.add(ob);
        }           

    }
    public ArrayList<WarehouseP> getList()
    {
        return list;
    }
}

Is it possible to create one uniwersal class "Import" and and only in main specify what type of List I wanna get? e.g

public static void main(String[] args){
    File warehousePFile = new File(path);
    ImportWarehouseP ImpWP = new Import<WarehouseP>();
    ImpWP.importWarehouseP(warehousePFile);
    ArrayList<WarehouseP> recordsWP = ImpWP.getList();
}

You're describing generics. http://docs.oracle.com/javase/tutorial/java/generics/ — Jeroen Vannevel, Jun 11 '14 at 14:06
@JeroenVannevel No he isn't, because generics cannot create the object. — Tim B, Jun 11 '14 at 14:10
Ah, you're right @TimB. Forgot Java can't instantiate a generic type. — Jeroen Vannevel, Jun 11 '14 at 14:16

score 0 · Answer 1 · answered Jun 11 '14 at 14:05

You do this using either an abstract class with a method to generate the object, or using the strategy pattern and passing in a factory to generate the object.

First Approach

new Import<WarehouseP>() {
   protected List<WarehouseP> buildList() {
       return new ArrayList<WarehouseP>();
   }
}

Where

abstract class Import<T> {
     protected abstract List<T> buildList();
}

Second Approach

new Import<WarehouseP>(new ListBuilder<WarehouseP>() {
   public List<WarehouseP> buildList() {
       return new ArrayList<WarehouseP>();
   }
});

Where

interface ListBuilder<T> {
     public abstract List<T> buildList();
}

The first approach is simpler, the second tends to be cleaner.

Creation of a universal (generic?) class i java

1 Answers1