Understanding of out covariance, in inversion and invariance in kotlin

java  in   ? extends T  amount to kotlin Medium out
String  yes  CharSequence  Subclasses of 
List<CharSequence> list = new ArrayList<CharSequence>();
List<? extends CharSequence> list2 = new ArrayList<String>(); // out T
 Generic concrete subclass objects can be assigned to the parent object at the generic declaration 
-------------------------------------------------------------
java  in  ? super T  amount to kotlin Medium in
List<? super String> list3 = new ArrayList<CharSequence>();
 The parent object of the generic concrete , Cannot be assigned to   Subclasses at the generic declaration 

// producer out  T   Covariance  [out T  This generic type can be obtained    Read   So it is out]
interface Producer<out T> {
    // out T  Represents the whole production class    This T  Can only be read , Do not modify 
    // Cannot be modified （ Compile not pass ）
//    fun consumer(item: T)
    // Can only be read 
    fun producer(): T
}

// consumer  in T   Inversion [in T  This generic can only be modified   to update   So it is in]
interface Consumer<in T> {
    // in T  Represents the whole consumer category    This T  Can only be modified , Cannot read 
    // Can only be modified 
    fun consumer(item: T)
    // Can't be read 
//    fun producer():T
}

// producers and consumers   T  By default ,  unchanged 
interface ProducerAndConsumer<T> {
    // Can be modified 
    fun consumer(item: T)

    // Can be read 
    fun producer(): T
}

open class Animal // animal 
open class Humanity : Animal() // human beings 
open class Man : Humanity()// Man 
open class WoMan : Humanity()// A woman 

class ProducerClass1 : Producer<Animal> {
    override fun producer(): Animal {
        println(" producer  Animal")
        return Animal()
    }
}

class ProducerClass2 : Producer<Humanity> {
    override fun producer(): Humanity {
        println(" producer  Humanity")
        return Humanity()
    }
}

class ProducerClass3 : Producer<Man> {
    override fun producer(): Man {
        println(" producer  Man")
        return Man()
    }
}

class ProducerClass4 : Producer<WoMan> {
    override fun producer(): WoMan {
        println(" producer  WoMan")
        return WoMan()
    }
}

/******************************************************/
class ConsumerClass1:Consumer<Animal>{
    override fun consumer(item: Animal) {
        println(" consumer  Animal")
    }
}

class ConsumerClass2:Consumer<Humanity>{
    override fun consumer(item: Humanity) {
        println(" consumer  Humanity")
    }
}
class ConsumerClass3:Consumer<Man>{
    override fun consumer(item: Man) {
        println(" consumer  Man")
    }
}
class ConsumerClass4:Consumer<WoMan>{
    override fun consumer(item: WoMan) {
        println(" consumer  WoMan")
    }
}

fun main(args: Array<String>) {
    val p1: Producer<Animal> = ProducerClass1()//ProducerClass1 It's delivery Animal
    val p2: Producer<Animal> = ProducerClass2()//ProducerClass2 It was originally a transmission Humanity  Yes out Modifiers can be turned into parent classes 
    val p3: Producer<Animal> = ProducerClass3()//ProducerClass3 It was originally a transmission Man  Yes out Modifiers can be turned into parent classes 
    val p4: Producer<Animal> = ProducerClass4()//ProducerClass4 It was originally a transmission WoMan  Yes out Modifiers can be turned into parent classes 
    // By default, generics are ： Subclass objects of generics , Cannot assign to a generic parent object 
    // By default, generics are ： Subclass objects in the specific place of the generic , Cannot assign to the parent object at the generic declaration 
    //out: Subclass objects of generics   Can be assigned to generic parent objects 
    //out: Generic concrete subclass objects can be assigned to the parent object at the generic declaration 
    // Covariance ： Parent class   Generic declaration Office   You can receive   Subclass generic concrete object 

    /*********************************************/

    val c1:Consumer<Man> = ConsumerClass1()//ConsumerClass Originally, it was Animal, Yes in  Modification can be converted into subclasses 
    val c2:Consumer<WoMan> = ConsumerClass1()//ConsumerClass Originally, it was Animal, Yes in  Modification can be converted into subclasses 
    // By default ： The parent object of the generic concrete , Cannot be assigned to   Subclasses at the generic declaration 
    //in:  The parent class of the generic concrete , Is a subclass that can be assigned to a generic declaration 

    //---------------------------------------------//
    // Covariance ： out  Parent class  =  Subclass 
    // Inversion ： in   Subclass  =  Parent class 
}