标签：1.6 Java 1.10 19 笔记 3.7 1.12 2.1

1. Scala

1.1. 混合了面向对象和函数式编程的语言

1.2. 直接使用任何一个Java类库

1.3. 声明非递归的方法时，不需要显式地返回类型

1.3.1. 会自动地替你推断生成一个

1.4. 字符串插值

1.4.1. 在字符串的字面量中内嵌变量和表达式

1.5. 以使用val关键字替换var

1.5.1. 关键字val表明变量是只读的，并由此不能被赋值

1.5.2. 关键字var表明变量是可以读写的

1.6. 集合

1.6.1. 在默认情况下都是不可变的

1.6.2. 默认都是持久化的

1.6.3. 并未强制你使用不可变集合，它只是让你能更轻松地在你的代码中应用不可变原则

1.6.4. scala.collection.mutable包中也包含了集合的可变版本

1.6.5. 不可修改集合仅仅是对可变集合进行了一层封装

1.6.6. 不可变（immutable）集合确保了该集合在任何时候都不会发生变化，无论有多少个变量同时指向它

1.6.7. 下划线是一种占位符

1.7. 元组

1.7.1. 元组字面量

1.7.2. 通过存取器（accessor）_1、_2（从1开始的一个序列）访问元组中的元素

1.8. Stream

1.8.1. 可以记录它曾经计算出的值，所以之前的元素可以随时进行访问

1.8.2. 需要存储这些额外的属性

1.8.2.1. Scala版本的Stream内存的使用效率变低了

1.8.2.2. 需要在内存“记录下来”（即进行缓存）

1.9. Option

1.9.1. 应该尽量地用它替代null，避免发生空指针异常

1.10. 函数

1.10.1. 函数类型

1.10.1.1. 一种符号，表示了在函数接口中声明的抽象方法的签名

1.10.1.2. 一种语法糖

1.10.2. 能够读写非本地变量的匿名函数

1.10.2.1. Java中的Lambda表达式无法对非本地变量进行写操作

1.10.3. 对柯里化的支持

1.10.3.1. 可以将一个接受多个参数的函数拆分成一系列接受部分参数的函数

1.10.3.2. 使用语法糖调用apply方法

1.10.4. 闭包是一个函数实例，它可以不受限制地访问该函数的非本地变量

1.11. 类

1.11.1. 构造器、getter方法以及setter方法都能隐式地生成

1.12. trait

1.12.1. 有助于抽象对象的特性

1.12.1.1. 一种同时包含了字段和默认方法的接口

1.12.1.2. 为实现Java中的接口而设计的替代品

1.12.2. 可以定义抽象方法

1.12.3. 可以定义带有默认实现的方法

1.12.4. 支持Java中接口那样的多继承

1.12.5. 对状态的多继承

1.12.5.1. java不可以

1.13. 对尾部调用进行了优化

2. 未来

2.1. 声明处型变

2.1.1. declaration-site variance

2.2. 模式匹配

2.2.1. 传统面向对象的设计不推荐大家使用switch，它更推崇使用设计模式，比如访问者模式，依赖数据类型的控制流是由方法分发器而不是switch语句选择的

2.2.2. 函数式程序设计语言来说，基于数据类型的模式匹配通常是设计程序最便捷的方式

2.3. 具化泛型

2.3.1. reified generic

2.3.2. 泛型多态的消除模式

2.3.2.1. erasure model of generic polymorphism

2.3.3. 泛型多态的具化模式

2.3.3.1. reified model of generic polymorphism

2.4. 基本类型特化和泛型

2.5. 对不变性的更深层支持

2.5.1. 值类型

2.5.1.1. 由于没有引用特征，因此占用的存储空间更少

2.5.2. 值对象

2.5.2.1. 既非基本类型又非对象类型

3. 回顾

3.1. 行为参数化（Lambda以及方法引用）

3.2. 流

3.2.1. 数据集越大，减少遍历数据集的次数就越重要

3.3. CompletableFuture

3.3.1. 以函数式程序设计的方式对Future的通用模式进行细粒度的控制，帮助你避免采用命令式编程时常见的模板代码

3.3.2. 提供了thenCompose、thenCombine和allOf这样的操作

3.4. Optional

3.5. Flow API

3.5.1. Java 9对反应式流进行了标准化

3.5.2. 基于拉模式的反应式背压协议能避免慢速消费者被一个或多个快速生产者压垮

3.6. 默认方法

3.7. Java 9的模块系统

3.7.1. Java 9对后向兼容性的损害也是最大的

3.7.2. 不采用模块系统

3.7.2.1. 恶意代码可能直接访问你模块的关键部分，直接绕开它所有的安全检查

3.7.2.2. 无法避免暴露运行于同一环境中安全相关的方法

3.7.3. 优势

3.7.3.1. 可靠的配置

3.7.3.1.1. 显式声明模块的依赖性，错误可以在很早的时候，就借由编译检测到

3.7.3.2. 严格的封装

3.7.3.2.1. 对模块的公有访问、每个模块的访问边界以及内部实现进行区分

3.7.3.3. 改进的安全性

3.7.3.4. 更好的性能

3.7.3.4.1. 一个类只能被有限的组件访问

3.7.3.4.2. 不是任何类都能在运行时加载它

3.7.3.5. 扩展性

3.7.3.5.1. 将Java SE平台解构成更细粒度的组成部分

3.7.3.5.2. 只执行运行你的应用所需要的特性

3.8. Java 10的局部变量类型推断

3.8.1. 如果类型只有唯一的标识符，那么采用类型推断能带来很多好处，其中最主要的优势之一是，当用一种类型替换另一种类型后，不用重新编辑修改代码了

标签：1.6,Java,1.10,19,笔记,3.7,1.12,2.1
From： https://www.cnblogs.com/lying7/p/17126985.html