Question

编辑：设置

有一个解析器从ProgramFactory调用方法，这个工厂使用表达式，语句，类型和程序，如下面的实现的标题中所示。 ProgramFactory实现了IProgramFactory，这是一个看起来像public interface IProgramFactory<E, S, T, P>

的接口

我似乎遇到的问题是Expression也是通用的，我不知道如何在实现中（在标题和方法中）得到正确的结果

当只返回类型为Expression类型时，它似乎有用

    @Override
public Expression<Boolean> createTrue(SourceLocation sourceLocation) {
    True expr = new True();
    return expr;
}

但不是当变量也是Expression

类型时

我这样做是为了返回类型和参数类型的通配符不必是一样的

public abstract class BinaryExpression<T, R> extends Expression<T>{
    Expression<R> left;
    Expression<R> right;
}

在接口的实现中，我似乎一遍又一遍地遇到同样的问题。

Expression is a raw type. References to generic type Expression<T> should be parameterized

问题是当我对这些表达式进行参数化时，他们告诉我接口没有这种方法。

The method createAddition(Expression<Double>, Expression<Double>, SourceLocation) of type ProgramFactory must override or 
 implement a supertype method

这是实现的样子

@Override
public Expression<Double> createAddition(Expression left, Expression right, SourceLocation sourceLocation) {
    Addition expr = new Addition(left, right);
    return expr;
}

这就是界面的样子

/** An expression that evaluates to the sum of the given expressions */
E createAddition(E left, E right, SourceLocation sourceLocation);

这是类Addition的样子

public class Addition extends BinaryExpression<Double, Double>{ 
    public Addition(Expression<Double> left, Expression<Double> right){
        this.left = left;
        this.right= right;
    }

     @Override
     public Double eval() {
         Double sum = left.eval() + right.eval();
         return sum;
     }
}

这就是Expression类的样子

public abstract class Expression<T> {
    public abstract T eval();
}

这是实现的标题看起来像

public class ProgramFactory implements IProgramFactory<Expression<?>, Statement, Type, Program>{

Answer 1

您没有提供完整的界面实施。所以我认为它类似于：

class MyImplementation implements Interface<Expression> {
        @Override
        public Expression<Double> createAddition(Expression left, Expression right, SourceLocation sourceLocation) {
            Addition expr = new Addition(left, right);
            return expr;
        }
}

但应该像：

class MyImplementation implements Interface<Expression<Double>> {
        @Override
        public Expression<Double> createAddition(Expression<Double> left, Expression<Double> right, SourceLocation sourceLocation) {
             Addition expr = new Addition(left, right);
             return expr;
        }
}

这是原始类型Expression = |Expression<E>|。在方法参数中使用简单的Expression可以删除类型参数。您不能在接口实现中声明raw Expression并使用带参数（CTE）的参数覆盖方法。考虑类型参数，就像它们是简单的别名一样。

Answer 2

你的表达式类应如下所示，

class Expression<T> {
  ....
}

您的界面应如下所示，

@Override
public Expression<?> createAddition(Expression<?> left, Expression<?> right, SourceLocation sourceLocation) {
     Addition expr = new Addition(left, right);
     return expr;
}

并且还将Expression类作为通用类。创建你的

它将解决您的问题。

Answer 3

如果您明确地参数化了界面中的所有参数：

public interface IProgramFactory<T> {
  public Expression<T> createAddition(
      Expression<T> left,
      Expression<T> right,
      SourceLocation sourceLocation
  );
}

然后你可以这样做：

public class ProgramFactory implements IProgramFactory<Double>{
  @Override
  public Expression<Double> createAddition(
      Expression<Double> left,
      Expression<Double> right,
      SourceLocation sourceLocation
  ){
    Expression<Double> expr = new Addition( left, right );
    return expr;
  }
}

使用泛型类

3 个答案: