Schreiben einer Klasse in einer typsicheren Weise

Question

Ich möchte einen typsicheren Code schreiben. Hier ist, was ich versucht habe:

public interface ResultTronsformer<T>{ 
    public T tranform(T t); 
} 

public class BigDecimalTransformer implements ResultTRansformer<BigDecimal>{ 

    public BigDecimal transform(BigDecimal t){ 
     return t.setScale(0); 
    } 
} 

Jetzt habe ich die Spalte Schnittstelle definieren, die wie

public interface Column{ 
    public ResultTransformer<?> getTransformer(); 
} 

sieht und möchte es in dem Verfahren verwenden

public class Report{ 
    private Map<Column, Object> columnValuePairs; 

    public void putIntoACollection(Column c, Object columnsValue){ 
     ResultTransformer<?> rt = c.getTransformer(); 
     columnValuePairs.put(c, rt.transform(o)); //Error: Couldn't convert Object 
                //to the capture of wildcard 
    } 
} 

Wie kann ich neu ordnen das Design, um die gewünschte Typ-Sicherheit zu erreichen? Vielleicht sollte ich stattdessen zur Laufzeit die Typprüfung durchführen (Ausnahme auslösen)?

Answer 1

Sie können die Column Klasse ändern und machen es parametrisiert:

public interface Column<T> { 
    public ResultTransformer<T> getTransformer(); 
} 

Dann müssen Sie die putIntoACollection Methode parametrisieren (keine Notwendigkeit Report parametrisieren):

public class Report { 
    private Map<Column, Object> columnValuePairs; 

    public <T> void putIntoACollection(Column<T> c, T columnsValue) { 
     final ResultTransformer<T> rt = c.getTransformer(); 
     columnValuePairs.put(c, rt.transform(columnsValue)); 
    } 
} 

Auf diese Weise, die Sie nie müssen einen Erfassungstyp verwenden. Hier

ist ein Beispiel dafür, wie Sie es verwenden würden:

private class BigDecimalColumn implements Column<BigDecimal> { 
    @Override 
    public ResultTransformer<BigDecimal> getTransformer() { 
     return new BigDecimalTransformer(); 
    } 
} 

public static void main(String[] args) { 
    final Report report = new Report(); 
    report.putIntoACollection(new BigDecimalColumn(), new BigDecimal("3.14")); 
} 

Answer 2

Wenn Sie den Transformator zu erhalten, müssen Sie den Typen angeben, da die Compiler es nicht zu dieser Zeit kennen.

Eine mögliche Lösung besteht darin, die Klasse als Parameter zum getTransformer der Spalte hinzuzufügen und einen spezialisierten ResultTransformer zurückzugeben.

Ein anderer Weg wäre, die Schnittstelle Spalte zu verallgemeinern.

Answer 3

Sie können über die Spalte genau wie über eine Art Container denken, der einen bestimmten Typ enthält. Auf diese Weise können Sie in der Spalte Deklaration einen generischen Typ einführen.

public interface Column<T>{ 
    public ResultTransformer<T> getTransformer(); 
} 

Dann können Sie Bericht Verfahren wie folgt ändern: roh Typ

 ResultTransformer rt = c.getTransformer(); 

public <T> void putIntoACollection(Column<T> c, T columnsValue){ 
     ResultTransformer<T> rt = c.getTransformer(); 
     columnValuePairs.put(c, rt.transform(columnsValue)); 
} 

Answer 4

Wir konnten alle Vorwände aufgeben, nur der Gott verdammt verwenden, um eine anspruchsvollere Lösung -

static <T> T transform (ResultTransformer<T> rt, Object obj) 
    { 
     T t = (T)obj; // unchecked cast 
     return rt.transform(t); 
    } 


public void putIntoACollection(Column c, Object obj){ 
    ResultTransformer<?> rt = c.getTransformer(); 
    columnValuePairs.put(c, transform(rt, obj)); 

}