《On Java 8》阅读笔记——对象与函数式编程

《On Java 8》是事实上的《Java 编程思想》第5版。
《On Java 8》中文版（兴趣人员自译）

面向对象与java

1、所有编程语言都提供抽象机制，问题的复杂度直接取决于抽象的类型和质量。为利用计算机解决问题，需要在问题模型（“问题空间”）与机器模型（站在计算机角度的“解决方案空间”）之间建立联系。为机器建模的另一个方法是为要解决的问题制作模型，一些早期语言为问题制作模型，却只适合解决某一类的问题，一旦超出了力所能及的范围，就会显得非常笨拙。面向对象的程序设计可直接利用一些工具表达问题空间内的元素，更加灵活与强大。

2、在程序设计中，对象是服务提供者。而程序为用户提供服务，是通过调用对象提供的服务实现的。

3、protected：基本等同于 private，区别是子类可以访问 protected 的成员，但不能访问 private 成员。
default：如果你不使用前面的三者，默认就是 default 访问权限。default 被称为包访问，因为该权限下的资源可以被同一包（库组件）中其他类的成员访问。

5、整件与组件，生命周期不同步是聚合关系，生命周期同步则是组合关系。
聚合关系多个整件可同时共享同一个组件，组合关系多个整件不可同时共享同一个组件。

6、在创建新类时首先要考虑组合而非继承，因为它更简单灵活，而且设计更加清晰。

7、面向对象语言使用后期绑定实现多态性，java用一个特殊的代码位来代替绝对调用，这段代码使用对象中存储的信息来计算方法主体的地址。java默认动态绑定。

8、java仅可在堆中创建对象，拥有知道对象什么时候不再被使用并且自动释放内存的垃圾收集器。

对象

1、引用：用来关联“对象”。我们所操纵的标识符实际上只是对对象的“引用”。

2、数据存储：
寄存器(Registers)：位于CPU，无直接控制权。
栈内存(Stack)：位于RAM，程序需要知道所有项的生命周期，通过栈指针控制，存储对象引用等信息。
堆内存(Heap)：位于RAM，程序不需知道所有项的生命周期，存储对象。
常量存储(Constant storage)：位于代码，就是常量值。
非 RAM 存储(Non-RAM storage)：位于程序外，序列化对象(字节流)、持久化对象

3、基本类型的数组默认全部置零来保证初始化

4、对象作用域：引用 s 在作用域终点会被清理，但是引用 s 指向的字符串对象依然还在占用内存，其生命周期不受作用域影响。若该对象在这个作用域之后依然被访问，它会一直存在，直至不再需要被垃圾收集器释放。

{
    String s = new String("a string");
} 

5、方法名和参数列表统称为方法签名（signature of the method）。签名作为方法的唯一标识。

函数式编程

1、OO(object oriented，面向对象)是抽象数据，FP(functional programming，函数式编程)是抽象行为。

2、方法引用：Class::method object::method 由 :: 区分。在 :: 的左边是类或对象的名称，在 :: 的右边是方法的名称，但没有参数列表。

3、Lambda表达式：parameter -> function 由箭头 -> 分隔开参数和函数体，箭头左边是参数，箭头右侧是从 Lambda 返回的表达式，即函数体。

4、方法引用和 Lambda 表达式的出现让我们可以在需要时传递功能

5、Lambda表达式看起来是产生函数，但实际上是只有一个方法的类。 在 JVM中一切都是一个类，因此在幕后执行各种操作使 Lambda 看起来像函数。

6、lambda表达式与方法引用进行功能传递时，签名（参数类型和返回类型）必须相对应，且接收方有函数式接口：

interface Callable {
	void call(String s);
}

class A{
	void a(String msg){
		System.out.println(msg);
	}
}

Callable c = A::a;

7、未绑定的方法引用：Class::method 在 :: 的左边是类，且method为非静态方法的时候，因为此时不存在该类的对象，方法也不在内存中，也就无法方法引用。

解决方案：函数式接口加一个 this 参数，调用时将该类的对象作为参数传递。

interface TransformX {
  String transform(X x, int num);
}

class X {
  String f(int a) { return a + 1; }
}

TransformX sp = X::f;
X x = new X();
sp.transform(x, 0);

此时签名不同了，因为需要一个对象来调用方法。看起来似乎很累赘，不如直接使用绑定的方法引用。（想到个：X设为接口，别的类实现X，利用多态提高可扩充性？）

8、构造函数引用：Class::new 捕获构造函数的引用，然后通过引用调用该构造函数。 new是固定用法。（闲出事了用一个方法引用来替换构造函数）

class Dog {
  String name;
  Dog() { name = "stray"; }
  Dog(String nm) { name = nm; }
}

interface MakeNoArgs {
  Dog make();
}

interface Make1Arg {
  Dog make(String nm);
}

public class CtorReference {
  public static void main(String[] args) {
    MakeNoArgs mna = Dog::new;
    Make1Arg m1a = Dog::new;

    Dog dn = mna.make();
    Dog d1 = m1a.make("Comet");
  }
}

可以看到方法引用得来的都是一个只含与接口吻合的特定函数的类。

9、函数式接口：只包含一个抽象方法的接口（SAM接口，Single Abstract Method interfaces）。可以使用@FunctionalInterface注解在接口上，不是必须的，但方便编译器检查是否为函数式接口。

10、java.util.function包 有一些接口，这些接口是 Lambda 表达式和方法引用的目标类型。把这些接口全背过以后就不需要自己写interface了，默写一个加个泛型就能直接用。

因为内容过多，放在别的文章：java.util.function包的基本命名准则、目标类型与示例

11、高阶函数(Higher-order Function)：用来消费或产生函数的一个函数。

interface FuncSS extends Function<String, String> {}

public class ProduceFunction {
  static FuncSS produce() {
    return s -> s.toLowerCase();
  }
  public static void main(String[] args) {
    FuncSS f = produce();
    System.out.println(f.apply("YELLING"));
  }
}

这里，produce() 是高阶函数。当然以上是产生一个函数，还有消费一个函数。

class One {}
class Two {}

public class ConsumeFunction {
  static Two consume(Function<One,Two> onetwo) {
    return onetwo.apply(new One());
  }
  public static void main(String[] args) {
    Two two = consume(one -> new Two());
  }
}

12、闭包：闭包就是能够读取函数作用域之外的变量的函数。

考虑一个返回复杂的 lambda 的高阶函数，使用了函数作用域之外的变量，返回该函数会发生什么？

java支持闭包，即在词法上限定范围（也使用术语“变量捕获”）。如果一个变量拥有独立的生存周期，那么并且不需要任何特殊的捕获。

从 Lambda 表达式引用的 局部变量，必须是 final 或者是等同 final 效果的。

等同 final 效果（Effectively Final）：这个术语是在 Java 8 才开始出现的，表示虽然没有明确地声明变量是 final 的，但是因变量值没被改变过而实际有了 final 同等的效果。

等同 final 效果意味着可以在变量声明前加上 final 关键字而不用更改任何其余代码。

因为示例有点多，写入新文章：Java8新特性：等同 final 效果(Effectively Final)（重要）

13、函数组合(Function Composition)意为“多个函数组合成新函数”。

以下：每一个compose() 和 andThen()，返回的都是一个组合函数。 compose()是先执行，andThen是后执行。所以函数 f 的执行顺序为：f2 → f1 → f3 。值得注意的是：三个函数各自执行各自的apply()方法，并且 下一个函数执行apply()的参数，是上一个函数的返回值。

f = f1.compose(f2).andThen(f3);
f.apply(obj);

以下：如果字符串中不包含 bar 且长度小于 5，或者它包含 foo ，则结果为 true。

Predicate<String>
    p1 = s -> s.contains("bar"),
    p2 = s -> s.length() < 5,
    p3 = s -> s.contains("foo"),
    p4 = p1.negate().and(p2).or(p3);

14、柯里化：将一个多参数的函数，转换为一系列单参数函数。

//未柯里化
BinaryOperator<String> uncurried = (i, j) -> i + j;

//柯里化   a -> ( b -> (a + b) )
Function<String, UnaryOperator<String>> sum = a -> b -> a + b;

这里的 b -> a + b ，也是闭包。

很有意思，但是感觉有点难用到，于是网上找了找用途：1. 延迟计算 2. 动态创建函数 3. 参数复用