Java - 闭包

1. 概述
   1. 简单介绍 闭包

1. 聚合关系

1. 概述

   1. 常见的 类间关系

2. 场景

   1. 类 A

      1. 主要类
      2. 持有 类B 的实例
      3. 有点行为, 需要 类 B 的介入

   2. 类 B

      1. 有自己的行为
      2. A 会在某些时候调用 B 的行为

3. 代码示例

   1. 伪代码

      class B:
          public void method1():
              actions;
      
      class A:
          private B b;
      
          public A(B b):
              this.b = b;
      
          public void m1():
              this.b.method1();
      

   2. 代码

      1. 伪代码有点坑
      2. 代码的话, 有机会会做补充

2. 换一个角度

1. 概述

   1. 闭包

2. 闭包

   1. 可以调用的对象
   2. 包含了作用域的信息
   3. 这玩意也不是什么类间关系
      1. 为啥把它和 聚合 放一块

3. 场景

   1. 类 A

      1. 单一类
      2. 持有 类B 的实例

   2. 类 B

      1. 是 类A 的属性
      2. 是 A 的 内部类
      3. 实现了 接口I

   3. 接口I

      1. 被 B 实现
      2. 作为 引用对象, 接收 B 类实例

4. 示例

   1. 伪代码

      interface I:
          void method1();
      
      class A:
          
          class B implements I:
              public void method1():
                  A.this.method1();
      
          public void method1():
              actions
      
          public I getCallbackRef():
              return new B();
      

   2. 代码

      1. 有空再补

5. tips

   1. 内部类

      1. 内部类持有 外部类 的一个引用
         1. 通过 OuterClass.this 来获取

   2. getCallBackRef

      1. 返回一个 I 类型的对象

         1. 实现方法
         2. 方便外面接收实例

      2. 实际返回的, 是 内部类 的实例

   3. 内部类的 method1

      1. 来自 I 的实现

      2. 实际行为

         1. 需要靠 A 来执行

   4. 然后一个类比

      1. 模型

         1. 类A 持有 类B
         2. 类A 的行为, 由 类B 来执行

      2. 聚合

         1. 符合这个模型

      3. 闭包

         1. 内部类的角度, 也符合这个模型
         2. 当然有点别扭
            1. 别扭的是, 内部类持有了 外部类 的引用
            2. 其实, 这个也不用奇怪
               1. 内部类 外部类 的关系, 和 聚合关系, 并没有直接的 可比性
               2. 当然, 只是相似
                  1. 一个持有另一个

   5. 闭包

      1. 行为
         1. 得到一个 接口I 类型, 但实际为 内部类 的对象
            1. 当然, 这个接口, 也可以换成 抽象类
         2. 这个对象, 持有创建它的外部类
            1. 可以通过它, 暴露一些外部类的方法, 属性
            2. 可以通过这个持有, 保持外部类不被垃圾回收

3. 好了, 那闭包到底有什么用

1. 多重继承

   1. java 的继承

      1. 正常情况下, 只能继承一个类
      2. 接口实现多个, 这个另说

   2. 多重继承

      1. 也不是真正意义上的多重继承

      2. 思路

         1. 约定

            1. 类 Outer
               1. 外部类
            2. 类 Inner
               1. 内部类
            3. 类 Abs1
               1. 抽象类1
            4. 类 Abs2
               1. 抽象类2

         2. 场景

            1. Outer 继承 Abs1
            2. Inner 继承 Abs2
            3. Inner 实现 Abs2 方法
               1. 实现的时候, 可以引入 Outer 对象来做操作
               2. 虽然不是真正的多重继承, 但实质上已经可以这么认为
            4. Outer 实现方法, 返回 Abs2 类型的对象
               1. 实际返回 Inner 类型的实例
            5. 其他使用者, 用 Abs2 类型的引用, 来接住这个实例

ps

1. 类间关系

   1. ref
      1. 类和类之间的关系
   2. 关于 依赖 与 聚合

      1. 约定

         1. 类 A
            1. 主体类
         2. 类 B
            1. 被依赖
            2. 被聚合

      2. 依赖

         1. 重点
            1. A 的方法, 需要 B 来做参数
               1. 可能导致的结果, A 的行为, 会受到 B 影响

      3. 聚合

         1. 重点
            1. A 的属性, 是 B
               1. 可能导致的结果, A 的行为, 会受到 B 影响
                  1. 怎么和上面一样...

      4. 区别

         1. 依赖
            1. 强调的关系, 没有聚合那么紧密
            2. 临时产生一个交集
               1. 交互完了关系立马消失
         2. 聚合
            1. 关系相对紧密, 整体 与 部分 的关系
            2. 关系较为稳定
               1. 整体存在, 关系一直都存在

2. 内部类

   1. 这块暂时不细说
      1. Java 编程思想里, 有一章专门对这块做了详细的介绍

3. 其他

   1. 类间关系, UML

      1. 这块其实, 还是挺有用的

   2. js 闭包

      1. 我第一见到闭包, 其实是 js
      2. 但是至今没有理解

   3. 伪代码

      1. 这块最好还是总结下吧
         1. 伪代码其实是 思路的体现
            1. 强调重点
         2. 与具体的语法独立
            1. 写起来方便
            2. 可以翻译成其他语言
         3. 我至今没有学太好
            1. 第一见到, 是偏向 py 的伪代码
               1. 但是 java 中的很多东西, py 不好表达
         4. 所以希望还是能学会这个东西
            1. 最好有足够强的表达能力
            2. 希望可以简单易懂
            3. 翻译起来, 不那么费劲