एक प्रकार को सुरक्षित तरीके से लिखना

Question

मैं एक प्रकार-सुरक्षित कोड लिखना चाहता हूं। यहाँ मैं क्या करने की कोशिश की है या नहीं:

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

public class BigDecimalTransformer implements ResultTRansformer<BigDecimal>{ 

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

अब मैं कॉलम इंटरफ़ेस जो की तरह

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

लग रहा है परिभाषित करने और विधि

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

मैं कैसे पुनर्व्यवस्थित कर सकते हैं में उपयोग करना चाहते हैं वांछनीय प्रकार की सुरक्षा तक पहुंचने के लिए डिजाइन? शायद मुझे रनटाइम पर टाइप-चेकिंग करना चाहिए (अपवाद फेंकना)?

Answer 1

आप Column वर्ग बदल सकते हैं और कर सकते हैं यह parametrized:

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

तो फिर तुम putIntoACollection विधि (Report parametrize करने की कोई जरूरत) parametrize करने के लिए है:

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

इस तरह, आप कभी नहीं कैप्चर प्रकार का उपयोग करने की आवश्यकता है।

यहाँ कैसे आप इसका इस्तेमाल होता है की एक उदाहरण है:

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

जब आप ट्रांसफार्मर मिलता है, आप के प्रकार का उल्लेख करने की जरूरत है क्योंकि संकलक उस समय यह पता नहीं चलेगा।

कॉलम के getTransformer के लिए कक्षा को पैरामीटर के रूप में जोड़ने और एक विशेष परिणाम ट्रान्सफ़ॉर्मर को वापस करने का एक संभावित समाधान है।

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

इंटरफ़ेस कॉलम को सामान्यीकृत करने का एक और तरीका होगा।

Answer 3

आप कॉलम के बारे में सोच सकते हैं जैसे कि यह किसी प्रकार का कंटेनर है जो विशिष्ट प्रकार रखता है। इस तरह, आप कॉलम घोषणा में सामान्य प्रकार का परिचय दे सकते हैं।

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

उसके बाद, आप रिपोर्ट विधि इस प्रकार बदल सकते हैं:

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

Answer 4

हम सभी दावों सिर्फ भगवान शापित कच्चे प्रकार का उपयोग

 ResultTransformer rt = c.getTransformer(); 

एक और अधिक मिथ्याभिमानी समाधान दे सकते हैं, -

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

}