Viết một lớp học theo kiểu an toàn

Question

Tôi muốn viết một loại mã an toàn. Đây là những gì tôi đã cố gắng:

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

public class BigDecimalTransformer implements ResultTRansformer<BigDecimal>{ 

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

Bây giờ tôi xác định giao diện Cột trông giống như

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

và muốn sử dụng nó trong các phương pháp

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

Làm thế nào tôi có thể sắp xếp lại thiết kế để đạt được loại an toàn mong muốn? Có lẽ tôi nên làm các loại kiểm tra tại thời gian chạy thay vì (ném một ngoại lệ)?

Answer 1

Bạn có thể thay đổi lớp Column và làm cho nó parametrized:

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

Sau đó, bạn phải parametrize putIntoACollection phương pháp (không cần phải 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)); 
    } 
} 

Bằng cách này, bạn không bao giờ cần sử dụng loại chụp.

Dưới đây là một ví dụ về cách bạn sẽ sử dụng nó:

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

Khi bạn nhận được máy biến áp, bạn cần phải xác định loại vì trình biên dịch sẽ không biết nó ở thời điểm đó.

Một giải pháp có thể là thêm lớp làm tham số vào getTransformer của cột và trả về một trình kết xuất chuyên biệt 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); 
} 

Một cách khác là tổng quát cột giao diện.

Answer 3

Bạn có thể nghĩ về Cột giống như một loại container chứa loại cụ thể. Theo cách đó, bạn có thể giới thiệu kiểu generic trong khai báo Cột.

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

Sau đó, bạn có thể thay đổi Báo cáo phương pháp như sau:

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

Answer 4

Chúng ta có thể từ bỏ tất cả sự giả vờ, chỉ cần sử dụng thần nguyền rủa kiểu thô

 ResultTransformer rt = c.getTransformer(); 

Một giải pháp nhiều tính năng hơn -

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

}