Pisanie klasy w bezpiecznym trybie

Question

Chciałbym napisać kod bezpiecznikowy. Oto, co starałem:

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

public class BigDecimalTransformer implements ResultTRansformer<BigDecimal>{ 

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

Teraz zdefiniować interfejs kolumny, która wygląda jak

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

i chciałby używać go w metodzie

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 
    } 
} 

Jak mogę zmienić kolejność projekt do osiągnięcia pożądanego bezpieczeństwa typu? Może powinienem zamiast tego robić sprawdzanie typów w czasie wykonywania (zgłaszanie wyjątku)?

Answer 1

Można zmienić klasę Column i uczynić go parametryzowane:

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

Następnie trzeba parametrize metodę putIntoACollection (nie trzeba parametrize Report):

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)); 
    } 
} 

ten sposób nigdy trzeba użyć typu przechwytywania.

Oto przykład jak można go używać:

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

Gdy pojawi się transformator, trzeba określić typ bo kompilator nie będzie wiedział, to w tym czasie.

Możliwe rozwiązanie to dodanie klasy jako parametru do getTransformer kolumny i zwrócenie specjalistycznego ResultTransformer.

public interface ResultTransformer<T> { 
    public T transform(T t); 
} 

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

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

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

public interface ResultTransformer<T> { 
    public T transform(T t); 
} 

Innym sposobem byłoby uogólnienie kolumny interfejsu.

Answer 3

Możesz myśleć o kolumnie tak, jakby był to jakiś kontener, który ma określony typ. W ten sposób możesz wprowadzić typ ogólny w deklaracji kolumny.

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

Następnie można zmienić metodę Zgłoś następująco:

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

Answer 4

Możemy porzucić wszelkie pozory, wystarczy użyć Boga przeklęty typ surowy

 ResultTransformer rt = c.getTransformer(); 

A bardziej pretensjonalne rozwiązanie -

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)); 

}