Java抽象类错误

我试图理解为什么在抽象类中会出现错误

我有一个抽象类Token，一个扩展Token的类AddToken和一个创建AddToken对象的类ExpressionTokenizer

AddToken获取：

"Error: AddToken is not abstract and does not override abstract method compareTo(java.lang.Object) in java.lang.Comparable" 

所以我把AddToken抽象化了

class AddToken extends Token
{
 public AddToken()
 {
    super( 'A', "+", 4, 3 );
 }

}

然后ExpressionTokenizer获得：

Error: AddToken is abstract; cannot be instantiated

那么，我的选择是什么？我不理解最后一个错误，我没有理由重写令牌中的方法

这是一门课，还有很多课，但我从来没有学过超级，所以我在继续学习的过程中

代币

表达式标记器

class ExpressionTokenizer
{
  String expression;
  //The expression as a string

  int lexicalPointer,
    //Index of the first character of lexeme
    forwardPointer;
  //Index of the current character of lexeme

  public ExpressionTokenizer(String expr)
    /* Initialize tokenizer for the given expression.
     Set lexical pointer to the first character of the first lexeme.
     */
  {
    expression = expr;
    lexicalPointer = 0;
    skipWhiteSpace();
  }


  private void skipWhiteSpace()
    // Move the lexical pointer through the spaces and tabs between tokens.
  {
    while (lexicalPointer < expression.length() && 
           (expression.charAt(lexicalPointer) == ' ' || 
            expression.charAt(lexicalPointer) == '\t') )
    {
      lexicalPointer++;   
    }
  }

  private boolean isNotFinal(int state)
    /* The finite state machine has only two non-final states.
     This is a result of having the lexeme for all but one token 
     (NumberToken) be only one character long.
     */
  {
    return state == 0 || state == 1;
  }

  public Token getToken() throws InvalidCharacterException
    // Return the next token in the expression using a finite state machine
  {
    Token returnToken = null; 

    int state = 0;  //Starting state for the finite state machine

    forwardPointer = lexicalPointer;

    // The loop implements the finite state machine
    while (forwardPointer < expression.length()
             && isNotFinal(state)){

      char currentChar = expression.charAt(forwardPointer);

      switch (state){

        case 0: if (Character.isDigit(currentChar))
          state = 1;
        else
        {
          switch (currentChar)
          {
            case '+': state = 3; break;
            case '-': state = 4; break;
            case '*': state = 5; break;
            case '/': state = 6; break;
            case '%': state = 7; break;
            case '(': state = 8; break;
            case ')': state = 9; break;
            case '=': state = 10; break;
            default:  throw new InvalidCharacterException(currentChar);
          } // inner switch
        } //else
        break;

        case 1: if (Character.isDigit(currentChar))
          state = 1;
        else
          state = 2;
        break;
      }  // outer switch

      forwardPointer++;
    } // while

    // Determine returnToken based on final state
    if (state == 2){
      // forwardPointer advanced two characters beyond end of lexeme
      forwardPointer--;
      String lexeme = expression.substring(lexicalPointer,forwardPointer);
      returnToken = new NumberToken(lexeme);
    }
    else{

      switch (state){
        case 3: returnToken = new AddToken(); break;
        case 4: returnToken = new SubtractToken(); break;
        case 5: returnToken = new MultiplyToken(); break;
        case 6: returnToken = new DivideToken(); break;
        case 7: returnToken = new ModToken(); break; 
        case 8: returnToken = new LeftParenToken(); break;
        case 9: returnToken = new RightParenToken(); break;
        case 10: returnToken = new EqualSignToken(); break;
      } // switch
    } // else

    // Advance lexicalPointer to next token and return current token
    lexicalPointer = forwardPointer;
    skipWhiteSpace();
    return returnToken;

  } // getToken

  public boolean isEndOfExpression()
  {
    return lexicalPointer == expression.length();
  }

}

class ExpressionTokenizer
{
字符串表达式；
//将表达式转换为字符串
int词汇指针，
//词素首字索引
前向指针；
//词素的当前字符索引
公共表达式标记器（字符串表达式）
/*初始化给定表达式的标记器。
将词法指针设置为第一个词素的第一个字符。
*/
{
表达式=expr；
词汇指针=0；
skipWhiteSpace（）；
}
私有void skipWhiteSpace（）
//通过标记之间的空格和制表符移动词汇指针。
{
while（lexicalPointer

您的

令牌

类正在实现

Comparable

接口的原始形式，该接口需要一个

compareTo（Object）

方法

没有必要把它抽象化。改为实现通用表单：

//                               vvvvvvv
class Token implements Comparable<Token>

---

在方法上使用

@Override

注释也可以帮助捕获这些类型的错误，其中您认为正在重写或实现某个内容的方法实际上并没有重写或实现任何内容。

它甚至没有完全做到这一点-它有一个名为

CompareTo

的方法，与@JonSkeet相比，不是

好的捕获物。我刚刚在“compareTo”页面上进行了“查找”，找到了不区分大小写的匹配项。我甚至没有注意到大写字母“C”。
//                               vvvvvvv
class Token implements Comparable<Token>

//         v--- lowercase
public int compareTo(Token tok)