kotlin的in和out对应的是
java中带上界和下界的通配符？号。
【in】 等价于java中的【? super】
【out】 等价于java中的【 ? extends】
List<TextView> textviews = new ArrayList<Button>(); // ERROR
以上会报错！不能把子类的List对象赋值给父类List的引用。
这是java泛型的一种性质：covariance（协变）。
covariance（协变）
源自数学中的一种概念。
子类的泛型类型也属于泛型类型的子类。
你声明一个父类的List，我给你赋值一个子类的List对象也是可以的。
但是java的泛型不具备这种性质。
原因：java泛型在编译时的类型擦除，由于有类型擦除的存在，为了保证类型安全，java给泛型设置了这种限制。
TextView[] textviews = new Button[10];
在java中用数组中做类似的事情是不会报错的。
这是因为数组并没有在编译时擦除类型。
但是有这种需求怎么办？
使用通配符【? extends】即可。
List<? extends TextView> textViews = new ArrayList<Button>();
这种写法虽然解除了赋值的限制，但是会增加另一个限制：
在使用这个引用的时候，不能调用它的参数包含①类型参数的方法。
[注①：类型参数就是<>里面的东西]
也不能给它的包含类型参数的字段赋值，除了空值。
只能用它不能修改它。
使用场景：
当你遇到【只想使用，不需要修改】的情况，来让本来不具covariance性质的java支持covariance，以此来扩大变量或参数的接收范围。
public void printTexts(List<? extends TextView> textViews){
for(TextView textView: textViews){
Log.e(TAG,textView.getText());
}
}
List<Button> buttons = ...
printTexts(buttons);
contravariant（逆变）
与之相对的还有【? super】，它可以让你把父类的泛型类型对象赋值给子类的泛型类型声明，叫逆变或者反变。
使用它是附加的限制和【? extends】相反，在使用这种变量的时候，不能调用返回值包含类型参数的方法。
List<? super Button> textViews = new ArrayList<TextView>();
...
Button button = textViews.get(0); //报错！！！
错误：
public void addTextView(List<TextView> textViews){
TextView textView = ...;
textViews.add(textView);
}
...
List<View> views = new ArrayList<>();
addTextView(views);//报错！！！
正确：只希望有一个能承接这个TextView的List。
public void addTextView(List<? super TextView> textViews){
TextView textView = ...;
textViews.add(textView);
}
...
List<View> views = new ArrayList<>();
addTextView(views);
PECS法则
Producer extends, Consumer super
Kotlin中的泛型
//java:
List<? extends TextView> textViews;
List<? super Button> textViews;
//kotlin
var textViews : List<out TextView>
var textViews : List<in TextView>
out：这个变量只用来输出，不用来输入，只能读，不能写。
in：只能用来输入，不能用来输出，只能写，不能读。
kotlin的out和in不只可以用在变量和参数的声明里，还可以直接用在泛型类型声明时的类型参数上。它表示我的这个类型就只能用来输出或只能用来输入。什么意思？说白就是，它的作者根据它的功能判断出它所有的使用场景都是只能用来输出的或者只能用来输入的。
interface Producer<out T>{
fun producer(): T
}
interface Consumer<in T>{
fun consume(product: T)
}
为了避免我在每个使用的位置都给变量或者参数写上in或out这么麻烦（以下写法），那么就直接在类型创建的地方写上就一劳永逸了（以上写法），这其实是个简便写法。
val aProducer: Porducer<out A> = ...
val a = aProducer.produce();
...
val bProducer: Porducer<out B> = ...
val b = bProducer.produce();
在类型声明的时候就加上out或in，就表示你对这个类型的定位就是只用来产出或者消费。什么时候用！取决你对这个类的定位！
kotlin还可以在类型声明的时候用【*】来填写类型参数。术语叫Unbounded Wildcard，即没有上界和下界的意思。
//kotlin:
var textViews:List<*>
|| 等价于
var textViews:List<out Any>
//java:
List<?> textViews;
|| 等价于
List<? extends Object> textViews;
如果你的类型声明里已经有了out或者in，那么这个限制在变量声明时也依然存在。
interface Counter<out T : Number>{
fun count():T
}
...
var counter : Counter<*> = ...
|| 实际效果是👇
var counter : Counter<out Number> = ...
多重上界
java里泛型声明的时候可以通过extends设置上界，注意，这个是类型声明的上界，不是【? extends】，这个上界可以设置成多重的，用【&】连接，而在kotlin里，上界的设置从extends变成了【:】，多重上界写法要把类型从尖括号里拿出来写，并在前面加where关键字。只是把java的多重上界换了个写法而已。
//java
class Monster<T extends Animal & Food>{
...
}
//kotlin
class Monster<T> where T : Animal , T : Food{
...
}
reified
java泛型里的类型参数（就是那个T），它并不是真正的类型，而是一个代号，所以不能把它当做一个普通的类型来用，比如不能在方法里检查一个对象是不是T的实例。但在kotlin里可以加reified解除这种限制。不过reified自身有个限制，只能用来inline函数上
java：
<T> void printIfTypeMatch(Object item){
if(item instanceof T){//报错！！！
TLog.e(item)
}
}
kotlin：
inline fun <reified T> printIfTypeMatchI(item: Any){
if(item is T){
println(item)
}
}
