Java泛型与Kotlin高阶函数及语法糖

java泛型

什么是泛型？泛指一切类型

常使用 T R V K I O 表示

协变与形变

class MyClass {
    public static void main(String[] args) {
        List<Object> a = new ArrayList();
        List<String> b = new ArrayList();
        a = b; // 报错,为什么,a 需要 List<Objects>类型，而b 为List<String>类型
        *****************
        // 此时需要使用协变
        父类接收子类 协变 ? extends 
        List<? extends Object> c = new ArrayList(); // ? 为占位符，表示一个继承于Object的子类
        List<String> d = new ArrayList();
        c = d;// 正确!!!
        *****************
        List<Object> e = new ArrayList();
        List<String> f = new ArrayList();
        f = e;// 报错，f需要List<Object>类型，而e为List<String>类型，类型不匹配
        *****************
        // 此时需要使用形变
        子类接收父类 形变 ? super
        List<Object> g = new ArrayList();
        List<? super String> h = new ArrayList();
        h = g;// 正确！
    }
}

java泛型类的使用

注意：泛型类中的方法只是使用了泛型类类型作为参数的函数，不是泛型函数

// 泛型类
// T type
class Bag<T> {
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue {
        return this.value;
    }
    // main
    public static void main(String[] args) {
        // 前面<> 和 后面<> 必须指定一处类型
        Bag<String> schoolBag = new Bag<>();
        schoolBag.setValue("语文书");
        System.out.println(schoolBag.getValue());
    }
}

kotlin泛型类的使用

kotlin泛型类的使用

kotlin: out 这个类型只能作为返回值输出生产

kotln: in只能作为参数接受消费

class Bag<in I,out O>(var value: @UnsafeVariance I,var result: @UnsafeVariance O) {
    fun setValue(v1: I) {
        value = v1
    }
    fun getValue(): O {
        return result
    }
}

Kotlin泛型函数的使用

何为泛型函数？不确定参数或者返回值类型的函数就是泛型函数
1. 仅有一个泛型
```
fun <T> test() {}
fun <T> test1(): T {}
fun <T> test2(v1: T) {}
```
2. 放回值和参数类型均需要自己指定
```
fun <T,R> test(v1: T, v2: T): R? {
    return null
}
```
Kotlin高阶函数分析
1. 何为高阶函数与为什么需要使用inline?
  
  高阶函数是将函数用作参数或返回值的函数，实际开发过程中一般所有高阶函数都必须使用inline修饰，使之成为内联函数。不使用inline修饰高阶函数时，使用此类高阶函数会带来一些运行时的效率损失，因为编译时，每一个函数都是一个对象，内存分配（对于函数对象和类）和虚拟调用会引入运行时间开销，降低效率。当inline修饰了高阶函数时，此时编译时程序只是做了一个展开/替换（类似于C语言的宏定义），所以在许多情况下我们通过使用inline内联化 lambda 表达式来消除这类的开销。
2. lambda表达式分析
```
inline fun String.show1(lambda: (String) -> Unit) {
    // lamba表达式为String类型的形参，没有返回值
    // lambda 表达式里面是 it
    lambda(this)
}
inline fun String.show2(lambda: String.() -> Unit ) {
    // lambda 表达式里面是 this
    this.lambda()
}
fun main() {
    "jack".show1{
        println("hello $it")
    }
    "Merry".show2{
        println("hello $this")
    }
}
```
3. lambda与泛型的综合运用
  - 给任意一个类型添加一个扩展函数，lambda中使用it访问这个对象
```
fun <T> T.show1(lambda: (T) -> Unit) {
    lambda(this) // 在这个函数中this指代的是调用这个扩展函数类型为T的对象,并把它作为参数传递给lambda，
               //  在lambda中使用it访问这个对象
}
```
  - 给任意一个类型添加一个扩展函数，lambda中使用this访问这个对象
```
fun <T> T.show2(lambda: T.() -> Unit) {
    this.lambda() // this指代是调用这个扩展函数类型为T的对象，再将其作为调用lambda的对象
                // 在lambda中使用this访问这个对象
}  
```
  - 给任意一个类型添加一个扩展函数,并将这个对象传递给lambda表达式,lambda返回值的类型由lambda最后一行的结果决定
```
fun <T,R> T.show3(lambda: (T) -> R) {
   val result = lambda(this)
   println(result!!::class.java.name)
   // 上行可以打印出lambda表达式最后一行结果的值
}
```
- 运行效果如下
  
  屏幕截图 2022-05-29 172914.png
  
  屏幕截图 2022-05-29 173046.png

Kotlin语法糖分析

apply分析

apply作用：使用apply可以进行初始化操作

inline fun <T> T.myApply(lambda: T.() -> T): T {
    this.lambda()
    return this
}

also分析

also作用：使用also可以完成同时性的操作

inline fun <T> T.myAlso(lambda: (T) -> T): T {
    lambda(this)
    return this
}

run分析

run作用：使用run可以执行一段代码

inline fun <R> myRun(lambda: () -> R): R {
   return lambda()
}
inline fun <T,R> T.myRun(lambda: T.() -> R): R {
   return this.lambda()
}

with分析

inline fun <T,R> myWith(value: T,lambda: T.() -> R): R {
    return value.lambda()
}

forEach分析

forEach作用：使用forEach可以遍历完成相关的操作

inline fun <T> Iterable<T>.myForEach(lambda: (T) -> Unit): Unit {
   for (item in this) {
       lambda(item)
   }
}

Java泛型与Kotlin高阶函数及语法糖

Java泛型与Kotlin高阶函数及语法糖

java泛型

kotlin泛型类的使用

Kotlin泛型函数的使用

Kotlin高阶函数分析

Kotlin语法糖分析

推荐阅读更多精彩内容