如何从泛型中获取特定的返回类型

Question

我有课程属性

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

和枚举

Enum ParserType{
STRING,NUMBER,RANGE
}

和解析器接口

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
}

我在这里做的是在Attribute中引用解析器，并根据其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和双重如果DoubleParser

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

更新

感谢您的答复。.但是现在我想将该属性存储在地图中，但是当我做这样的事情时，它返回我对象

// 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对象时提供您的返回类型

解析器

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

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

Test.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());
    }
}

Answer 2

你可以做这样的事情。

class Attribute<T, R> {

    private final T value;

    private final Parser<T, R> parser;

    public Attribute(T value, Parser<T, R> parser) {
        this.value = value;
        this.parser = parser;
    }

    private R parse() {
        return parser.parse(value);
    }

    private interface Parser<T, R> {
        R parse(T t);
    }

    private static class StringParser implements Parser<String, String> {
        @Override
        public String parse(String s) {
            return s;
        }
    }

    private static class DoubleParser implements Parser<String, Double> {
        @Override
        public Double parse(String s) {
            return Double.parseDouble(s);
        }
    }

    public static void main(String[] args) {
        Attribute<String, String> stringAttribute = new Attribute<>("input", new StringParser());
        Attribute<String, Double> doubleAttribute = new Attribute<>("1.0", new DoubleParser());

        System.out.println(stringAttribute.parse()); //should print the string
        System.out.println(doubleAttribute.parse()); //prints the double value
    }
}

注–我已在同一类中添加了所有接口和类，以将示例保存在单个文件中，以便您复制和运行该示例而无需创建多个文件。

我还对结构进行了一些更改以使其更具可读性。 您可以在构造属性类期间提供解析器，而不是将ParserType保留在类中，然后确定要实例化的解析器。 属性类不应对此负责。