0

我刚开始使用抽象类型。我遇到了一个我无法完全理解的错误。这是我的一些背景代码

abstract class DbfReader( fileName: String )
{
    type DBFDataType <:Any
    type Key <:Any
    type Value <:Any

    abstract class FieldMapping
    {
        type FieldType
        def acronym: Key
        def longName: Key 
        def fieldNum: Int
        def getField: FieldType
        def getFieldLength: Int
    }

    def fieldMappings: Map[ Key, FieldMapping ]
    def getFieldCount: Int
    def hasRecord(): Boolean
    def getRecord(): DBFDataType
    def getFieldVal( fieldName: Key )( rowData: DBFDataType ): Value
    protected def createFieldMapping( fieldAcro: Key, 
                                      fieldLongName: Key, 
                                      fieldPosition: Int ): FieldMapping
....
}

抽象类 DbfReader 旨在成为我正在尝试的不同 DBF（数据库文件）读取库的抽象包装器。抽象类有一个 FieldMapping 的内部类（表元数据，它有一个抽象类型FieldType，它是数据库字段的底层库表示的占位符。getField内部类中的例程返回这种类型的引用。

以下是这个抽象类的具体实现：更多背景

class MyDBFReader( fileName: String, fmap: List[( String, String, Int )]  ) extends DbfReader( fileName )
{
    type DBFDataType = Array[Object]
    type Key = String
    type Value = String

    val dbReader = new jdbf.DBFReader( new java.io.FileInputStream( theFile ) )

    val fieldMappings = addFieldMappings(fmap)(Map())
    case class InnerFieldMapping( acronym: Key, longName: Key, fieldNum: Int) extends FieldMapping
    {
        type FieldType = jdbf.JDBField
        override def getField: jdbf.JDBField = dbReader.getField( fieldNum )
        def getFieldLength = getField.getLength
    }

    def getFieldCount = dbReader.getFieldCount
    def hasRecord = dbReader.hasNextRecord
    def getRecord = dbReader.nextRecord
    def createFieldMapping( fieldAcro: String, fieldLongName: String, fieldPosition: Int ) = InnerFieldMapping( fieldAcro, fieldLongName, fieldPosition )

    def getFieldVal( fieldName: Key )( rowData: DBFDataType ) = {
        if( fieldMappings.keySet.contains( fieldName ) ) stringer( rowData( fieldMappings( fieldName ).fieldNum - 1 ) )
        else
            throw new NoSuchElementException( "Key " + fieldName + " not Found" )
    }

    private def stringer( r: Object ) = r.asInstanceOf[String].trim
}

我遇到的麻烦是当我尝试从扩展抽象字段映射的 InnerFieldMapping 调用 getField 时。我在这样的单元测试中尝试这个：

问题出在哪里

class MyDBFSuite extends FunSuite {
    val fileName = "/Users/Me/api11bdb.dbf"
    val dbf = new MyDBFReader( fileName, DbfReader.SchoolFieldMapping )

    test( "Dbf should have 150 fields" )
    {
        assert( dbf.getFieldCount === 150 )
    }

    test( "Should read a record" )
    {
        assert( dbf.hasRecord === true )
        assert( dbf.getRecord.size === 150 )
    }

    test( "Should Get a Field" )
    {
        println( dbf.fieldMappings.head._2.getField.getType )
        //assert( dbf.fieldMappings.head._2.getField.getType === "S" )
    }

在最后一次测试中（无论是启用了断言还是在 println 中），每当我尝试访问 getType 时，这是一个例程，DBFField这是我期望从内部类InnerFieldMapping例程 getField 获得的。在抽象玻璃中，例程指定了一个返回类型FieldType，我在具体类中将其实现为 jdbf.JDBFField

但是编译器说： 问题

src/test/scala/ChinaDBFTestSuite.scala:23: value getType is not a member of MyDBFSuite.this.dbf.FieldMapping#FieldType
[error]         println( dbf.fieldMappings.head._2.getField.getType )
[error]                                                     ^

在另一个测试中，我调用外部类例程 getRecord，它在其抽象类中返回抽象类型。编译器在那里没有问题。查看错误消息，它似乎期望 FieldType 符合内部抽象类定义。我的意思是我希望它寻找 MyDBFSuite.this.dbg.InnerFieldMapping.FieldType。我在这里做错了什么吗？

编辑：非常感谢您的回答。作为后续，我还有一个关于覆盖的问题？我注意到在 scala book 中返回抽象类型的方法在子类型中被覆盖，但是我在这里不这样做，编译器在实例化子类型时不会抱怨缺少实现。当方法的返回类型是抽象类型（在基类中定义）时，为什么子类方法中需要覆盖标记？

4

1 回答 1

1

我认为这就是问题所在，最好用一个例子来说明。你的父类定义了这个：

def fieldMappings: Map[键，FieldMapping]

这必须同质地绑定到它在编译器期间调用的单一类型。例如，如果您在上面添加了第二个类，第二个“类型”并合法地开始将其添加到该地图中。（完全合法，两者都是 FieldMapping 的子类。）但是，接下来，Scala 怎么知道以后要做什么呢？

    dbf.fieldMappings.head._2.getField.getType
    dbf.fieldMappings.tail._2.getField.otherFunction

现在考虑一下，编译器在 .getField 之后不知道您在那里加载了 2 个类中的哪一个。也许头是你的第一个孩子班？也许它们都是您定义的第二个定义“otherFunction”的类？谁知道？

解决方案：

您可以在事后进行投射：

dbf.fieldMappings.head._2.getField match {
  case answer:jdbf.JDBField => answer
  case _ => throw new ClassCastException
}

或者，使用类型参数从上到下绑定所有内容 - 这可能是最易读和最安全的方式，因为它可以在编译期间被捕获。

abstract class DbfReader[T]( fileName: String )
{
    type DBFDataType <:Any
    type Key <:Any
    type Value <:Any

    abstract class FieldMapping
    {

        def acronym: Key
        def longName: Key 
        def fieldNum: Int
        def getField: T
        def getFieldLength: Int
    }

    def fieldMappings: Map[ Key, FieldMapping ]
    def getFieldCount: Int
    def hasRecord(): Boolean
    def getRecord(): DBFDataType
    def getFieldVal( fieldName: Key )( rowData: DBFDataType ): Value
    protected def createFieldMapping( fieldAcro: Key, 
                                      fieldLongName: Key, 
                                      fieldPosition: Int ): FieldMapping
....
}

总而言之，您不能拥有一个抽象类型的集合，该集合以某种方式稍后调用子类型而无需在运行时进行强制转换，即使您只定义了一个，它仍然是同一个问题。

于 2013-07-12T00:06:32.890 回答