java.lang.ClassCastException: подкласс не может быть приведен к суперклассу

Question

Я изменил класс, который реализует интерфейс суперкласса, который теперь выглядит следующим образом:

class TimestampConversion(format: String, formatter: SimpleDateFormat) extends ObjectConversion[Any] {
  override def execute(input: String): Timestamp = {
      // hidden implementation details
  }

  override def revert(input: Any): String = {
    // hidden implementation details
  }

  override def fromString(input: String): Timestamp = {
    // hidden implementation details
  }
}

object TimestampConversion {
  def apply(format: String): Try[TimestampConversion] = {
    // hidden implementation details
    new SimpleDateFormat().map(new TimestampConversion(format, _))
  }

}

После того, как я изменил код, я начал получать исключения при вызове при вызове этого класса.Этот класс работал, когда он был:

class TimestampConversion(format: String, formatter: SimpleDateFormat) extends ObjectConversion[Any] with FormattedConversion[SimpleDateFormat] {

  def this(format: String) = this(format, new SimpleDateFormat(format))

  override def execute(input: String): Timestamp = {
     // hidden implementation details
  }

  override def revert(input: Any): String = {
    // hidden implementation details
  }

  override def fromString(input: String): Timestamp = {
    // hidden implementation details
  }

  override def getFormatterObjects: Array[SimpleDateFormat] = {
    // hidden implementation details
  }
}

Иерархия подклассов TimestampConversion(sub) <-- ObjectConversion <-- NullConversion (super)

Когда я пытаюсь вызвать вызывающий мой недавно измененный класс TimestampConversion, я получаю это исключение

 java.lang.ClassCastException: 
...TimestampConversion cannot be cast to 
...NullConversion
at...my_parser$$anonfun$7.apply(my_parser.scala:65)
at ...my_parser$$anonfun$7.apply(my_parser.scala:59)

, где здесь вызывается TimestampConversion:

for ((col, i) <- all_cols) {
   val converter = col.type match {
      // hidden implementation details
      case TimestampType => TimestampConversion("some_format") // line 65 in my_parser
      case unknown => throw new RuntimeException("Met a bad type")
   }
}

, и раньше он назывался так (когда работал):

for ((col, i) <- all_cols) {
   val converter = col.type match {
      // hidden implementation details
      case TimestampType => new TimestampConversion("some_format")
      case unknown => throw new RuntimeException("Met a bad type")
   }
}

Я реализовал два @Override метода из интерфейса NullConversion, и я не получаю предупреждение или что-либо из моей IDE до компиляции, говоря, что TimestampConversion не полностью реализует NullConversion или что-то в этом роде.Я просто избавился от ассоциации с FormattedConversion.Почему я не могу вызвать свой класс таким образом?Я также никогда не касался классов ObjectConversion и NullConversion.

Вот структуры суперклассов:

public abstract class ObjectConversion<T> extends NullConversion<String, T> {

    public ObjectConversion() {
        super(null, null);
    }

    public ObjectConversion(T val, String nullVal) {
        super(val, nullVal);
    }

    @Override
    public T execute(String input) {
        return super.execute(input);
    }

    protected final T fromInput(String input) {
        return fromString(input);
    }

    protected abstract T fromString(String input);

    @Override
    public String revert(T input) {
        return super.revert(input);
    }

    @Override
    protected final String undo(T input) {
                // hidden implementation details
    }

    public T getValueIfStringIsNull() {
                // hidden implementation details
    }

    public String getValueIfObjectIsNull() {
                // hidden implementation details
    }

    public void setValueIfStringIsNull(T valueIfStringIsNull) {
                // hidden implementation details
    }

    public void setValueIfObjectIsNull(String valueIfObjectIsNull) {
                // hidden implementation details
    }

}

, и этот класс расширяет NullConversion<String, T>

public abstract class NullConversion<I, O> implements Conversion<I, O> {

    private O valueOnNullInput;
    private I valueOnNullOutput;

    public NullConversion() {
        this(null, null);
    }

    public NullConversion(O valueOnNullInput, I valueOnNullOutput) {
                // hidden implementation details
    }

    @Override
    public O execute(I input) {
                // hidden implementation details
    }

    protected abstract O fromInput(I input);

    @Override
    public I revert(O input) {
        // hidden implementation details
    }

    protected abstract I undo(O input);

    public O getValueOnNullInput() {
                // hidden implementation details
    }

    public I getValueOnNullOutput() {
                // hidden implementation details
    }

    public void setValueOnNullInput(O valueOnNullInput) {
                // hidden implementation details
    }

    public void setValueOnNullOutput(I valueOnNullOutput) {
                // hidden implementation details
    }
}

Кроме того, вот класс, который использовался для расширения старого кода FormattedConversion (хотя я сомневаюсь, что это имеет значение)

public interface FormattedConversion<T> {
   T[] getFormatterObjects();
}