java - 如何从 Generic 获取特定的返回类型

Question

我有类属性

class Attribute{
private Parser parser;
private String value;
private ParserType parseType;
}

和枚举

Enum ParserType{
STRING,NUMBER,RANGE
}

和解析器接口(interface)

interface Parser<S,T>{
 T parse(S s){
}
}

现在，根据不同的数据类型，我以不同的方式解析值。为此我创建了类

class StringParser implements Parser<String,String>{

@override
public String parse(String value){
return //... parse and return string
}

以类似的方式我有其他解析器

 class DoubleParser implements Parser<String,Double>{

@override
public Double parse(String value){
return //... parse and return double
}

我在这里所做的是在属性中引用解析器，并根据其ParserType设置不同类型的解析器

例如

class Attribute{
private Parser parser;
private String value;
private ParserType parseType;

Attribute(String value,ParserType parsertype){
 this.value=value;
 this.parserType=parserType
 }

private void setParserType()
 {
 switch(parserType){
  case ParserType.String:
   parser=new StringParser();
  break;

  case ParserType.Number:
  parser=new NumberParser();
  break;
 }

 }

  public void parse(){
  parser.parse(value); // here return type is object...  and i want it to be String if it is StringParser and bouble if it is DoubleParser
  }
}

如果您在Attribute类中看到parse()方法。我希望它在 StringParser 时给出 String 数据类型，如果是 DoubleParser

则给出 double

我知道我使用泛型做错了什么。所以我的问题是实现这一目标的最佳实践是什么？

已更新

感谢大家的回答..但是现在我想将属性存储在 map 中，但是当我做这样的事情时它会返回我对象

// I did changes in my Attribute class 
public T parse(){
return parser.parse(value); // here return type is object...  and i want it to be String if it is StringParser and bouble if it is DoubleParser
}

Map<String,Attribute> map;
//assuming my map has some entries
for(Map.Entry<String,Attribute> m:map.entrySet()){
 map.getValue().parse(); // this parse methods returns object to me here. I want it to be some specific type like String or Double
}

Answer 1

在创建 Attribute.java 对象时提供返回类型

解析器.java

interface Parser<S,T>{
     T parse(S s);
}

StringParser.java

public class StringParser<S> implements Parser<String, S>{
    @Override
    public S parse(String s) {
        return (S) "Hello";
    }
}

DoubleParser.java

public class DoubleParser<S> implements Parser<Double, S>{
    @Override
    public S parse(Double s) {
        return (S) new Double(1);
    }
}

属性.java

public class Attribute<T, R> {
    public T value;
    private Parser<T, R> parser;

    public Attribute(T value, String parserType) {
        switch (parserType) {
        case "ParserTypeString":
            parser = (Parser<T, R>) new StringParser<R>();
            break;
        case "ParserTypeNumber":
            parser = (Parser<T, R>) new DoubleParser<R>();
            break;
        }

    }

    public R parseReturn() {
        return parser.parse(value);
    }
}

测试.java

public class Test {
    public static void main(String[] args) {
        Attribute<String, String> str = new Attribute<String, String>("World", "ParserTypeString");
        System.out.println(str.parseReturn());

        Attribute<Double, Double> dbl = new Attribute<Double, Double>(5D, "ParserTypeNumber");
        System.out.println(dbl.parseReturn());
    }
}