Kotlin outprojected 类型禁止使用

You have created a conflict between your declarations of the Map and of the ItemParser. The map can contain any descendant of BaseItem but the ItemParser is designed that each descendant only operates on one of the descendants of BaseItem. So for a given instance of ItemParser it must accept something it can recognize and here you can't do that because your foundParser could be any descendant and not the one true expected type for that given ItemParser instance. Which T should it guess at?!? It cannot.

Therefore you have to design your API around the base class and not the descendants. You make it impossible for the compiler to know what is be passed to the parse() method. The only one true thing you can know is that it is a BaseItem instance.

只有you人知道你在使用map做什么，保证你用正确的类型调用正确的实例.编译器不知道你的逻辑，这就是保证.

I would suggest you change your API to add an internalParse method for which you cast do your work, wrapped by a generic parse function that double checks and does the evil cast.

abstract class BaseItem

class AmericanItem : BaseItem()
class EuropeanItem : BaseItem()

interface ItemParser<T: BaseItem> {
    @Suppress("UNCHECKED_CAST")
    fun parse(item: BaseItem) {
        val tempItem = item as? T 
             ?: throw IllegalArgumentException("Invalid type ${item.javaClass.name} passed to this parser")
        internalParse(tempItem)
    }

    fun internalParse(item: T)
}

class AmericanItemParser : ItemParser<AmericanItem> {
    override fun internalParse(item: AmericanItem) {
        println("AmericanItemParser")
    }
}

class EuropeanItemParser : ItemParser<EuropeanItem> {
    override fun internalParse(item: EuropeanItem) {
        println("parsing EuropeanItem")
    }
}

fun main(args: Array<String>) {
    val hashMap = HashMap<Class<out BaseItem>, ItemParser<*>>()
    hashMap.put(AmericanItem::class.java, EuropeanItemParser())
    hashMap.put(EuropeanItem::class.java, AmericanItemParser())

    val inputItem = EuropeanItem()
    val foundParser = hashMap[inputItem.javaClass]
    foundParser?.parse(inputItem)
}

Note you could also use the Kotlin class instead of the Java class which would be of type KClass<out T>.