java泛型

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

   常使用 T R V K I O 表示

2. 协变与形变

   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;// 正确！
       }
   }
   

3. 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泛型类的使用

1. 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)
     }
  }