java核心技术卷一

4对象与类

4.1面向对象程序设计概述

4.1.1类

1. 什么是类
   类就类似对象的模具

4.1.2对象

1. 什么是对象
   对象就是

4.1.3识别类

4.1.4类之间的关系

4.4 静态字段与静态方法

4.4.1 静态字段 即类共享字段

4.4.2 静态常量 不能修改的类公共字段

4.4.3 静态方法

1.什么是：不在对象上执行的方法，直接通过类来调用
2.怎么用：a.方法不需要对象状态;b.方法只需要访问类的静态字段

4.4.4 工厂方法

1.为什么需要工厂方法：a.无法命名构造器；b.使用构造器无法改变获得实例的类型

4.4.5 main方法

4.5 方法参数

Java方法参数总是按值引用，因此：
1.方法无法修改一个基本类型的参数
2.方法无法修改对象参数引用另外一个对象（方法的对象参数也是副本）
3.方法可以通过对象参数修改对象的状态

4.6 对象构造

4.6.1 重载

1.什么是：多个方法具有相同的名字，不同的参数
2.方法签名=方法名+参数类型，返回类型不是方法签名的一部分

4.6.2 默认字段初始化

4.6.3 无参数的构造器 没有提供构造器的类会默认提供一个无参构造器，反之，不提供无参构造器

4.6.4 显式字段初始化

4.6.5 参数名

4.6.6 调用另一个构造器 this(...)

4.6.7 初始化块

构造器的处理步骤：是否调用第二个构造器->默认初始化->初始化方法和初始化块->构造器方法代码；
常见问题，父类和子类的static代码，普通代码块，和构造方法的执行顺序

4.6.8 对象析构和finalize方法

4.7 包

4.7.1 包名 主要原因确定类的唯一性

4.7.2 类的导入 import语句

4.7.3 静态导入

4.7.4 在包中增加类

4.7.5 包访问

4.7.6 类路径

4.7.7 设置类路径

java -classpath
//在shell中临时指定
//linux
export CLASSPATH=...
//windows
set CLASSPATH=...

4.8 JAR文件

4.8.1 创建JAR文件

4.8.2 清单文件

4.8.3 可执行JAR文件

4.8.4 多版本JAR文件

4.8.5 关于命令行的说明

4.9 文档注释

4.9.1 注释的插入

4.9.2 类注释

4.9.3 方法注释

4.9.4 字段注释

4.9.5 通用注释

4.9.6 包注释

1.提供一个名为package-info.java文件
2.提供一个名为package.html文件

4.9.7 注释抽取

4.10 类设计技巧

1.一定要保证数据私有
2.一定要对数据进行初始化
3.不要再类中使用过多的基本类型
4.不是所有的字段都需要单独的字段访问器和字段修改器
5.分解有过多职责的类
6.类名和方法名要能体现他们的职责
7.优先使用不可变的类

5继承

5.1类、超类和子类

5.1.1 定义子类

5.1.2 覆盖方法

5.1.3 子类构造器

1.使用super调用构造器的语句必须是子类构造器的第一条语句
2.

5.1.4 继承层次

5.1.5 多态 设计继承关系的原则"is-a"原则

5.1.6 理解方法调用

静态绑定 staticfinalprivate修饰的方法或者构造器
动态绑定 查方法表

5.1.7 阻止继承:final类和方法

5.1.8 强制类型转换

• 只能在继承层次内进行强制类型转换
• 超类转子类之前，应该使用instanceof进行类型检查

5.1.9 抽象类##

5.1.10 受保护访问

5.2 Object:所有类的超类

5.2.1 Object类型的变量

5.2.2 equals方法

5.2.3 相等测试与继承

1. 相等性测试的特性：

• 自反性
• 对称性
• 传递性
• 一致性
• 非空对象equals(null)必须返回false

2. 相等性测试的两种情形：

• 相等性由子类自己决定：那么需要getClass在同个子类中进行比较
• 相等性由超类决定，希望能在不同子类中确定相等性：那么可以通过instanceof检测

5.2.4 hashCode方法

5.2.5 toString方法

5.3 泛型数组列表

5.3.1 声明数组列表

5.3.2 访问数组列表元素

5.3.3 类型化与原始数组列表的兼容性

5.4 对象包装器和自动装箱

5.5 参数数量可变的方法

5.6 枚举类

5.7 反射

5.7.1 Class类

获得class的三种方法
1.getClass();2.Class.forName();3.class

5.7.2 声明异常入门 非检查型异常和检查型异常

5.7.3 资源

5.7.4 利用反射分析类的能力

5.7.5 使用反射在运行时分析对象

5.7.6 使用反射编写泛型数组代码

5.7.7 调用任意方法和构造器

5.8 继承的设计技巧

6 接口，lambda表达式与内部类

6.1 接口

6.1.1 接口的概念 希望类实现的需求（需求）

6.1.2 接口的属性

1.接口不能包含实例字段，但是可以包含常量，接口中的字段总是public static final

6.1.3 接口与抽象类

6.1.4 静态和私有方法

java8 允许接口中增加静态方法

6.1.5 默认方法

貌似主要是为了扩展接口而产生的，同时能把抽象类中共同的方法往上提一级

6.1.6 解决默认方法冲突

接口有多继承，那么必然出现冲突解决问题
1.超类优先
2.接口冲突（默认方法只要有一个实现）必须覆盖
3.类优先

6.1.7 接口与回调 指定某个特定事件发生时的处理动作，异步编程的基础哈

6.1.8 Comparator接口

为已经实现或者不能实现compareTo方法的类提供比较器

6.1.9 对象克隆

必须当心子类的克隆
已经实现了Clonable接口，并且重写为public的类的子类可以使用父类提供的clone方法，并且不会对需要深拷贝的字段进行处理，需要自己处理，否则对克隆对象的修改会影响被克隆对象

6.2 lambda表达式

6.2.1 为什么引入lambda表达式

传递代码块的简洁方式，函数式编程异步编程的需求

6.2.2 lamdba表达式的语法

6.2.3 函数式接口 只有一个抽象方法的接口

1.BiFunction<T,U,R>
2.Predicate
3.Supplier 供应者用于实现懒计算，比如Objects.requireNonNullOrElseGet(day,()->new LocalDate(1970,1,1))只有在需要时才生成对象

6.2.4 方法引用

lambda表达式的快捷方式

6.2.5 构造器引用

6.2.6 变量作用域

1.捕获自由变量（闭包），自由变量值不能改变
2.变量的作用域
3.lambda表达式中的this指创建表达式的方法的this对象

6.2.7处理lambda表达式 lamda表达式的重点是延迟执行

6.2.8 在谈Comparator

1.使用comparing提取比较内容，还可以针对内容的比较器
2.返回的null，可以通过nullFirst和nullLast来处理

6.3 内部类

1. 使用内部类的原因： 能够对同一个包的其他类隐藏；能够访问外部类的私有域

6.3.1 使用内部类访问对象状态

6.3.2 内部类的特殊语法规则

1.内部类中声明的所有静态字段必须是final
2.内部类不能有static 方法。

6.3.3 内部类是否有用、必要合安全

1.外部类是个编译器现象

6.3.4 局部内部类

声明局部内部类的时候不能有访问说明符，它的作用域只在方法内；曾经是回调代码传递的重要方法

6.3.5由外部方法访问变量

局部内部类可以访问局部变量，和lambda相似，访问的局部变量必须是事实最终类

6.3.6 匿名内部类

1.匿名类不能有构造器，其构造参数传递给超类，如果匿名内部类实现的是一个接口，那么不能有构造参数

6.3.7 静态内部类

1.静态内部类可以声明静态方法和字段

6.4 服务加载器

6.5 代理

6.5.1 何时使用代理

1.希望构造一个类，实现某些编译时并不知道的接口
2.能够将这些接口，在运行时构造为新类

6.5.2 创建代理对象

6.5.3 代理类的特性

1.一个代理类只有一个调用处理器。完成处理对象任务的任何额外数据都必须存储在调用处理器
2.所有的代理类都要覆盖Object类的toString,equals,hashCode方法
3.没有定义代理类的名字，将生成一个$Proxy开头的类名
4.对于一个特定的类加载器和预设的一组接口来说，只能有一个代理类
5.代理类总是public和final

7 异常、断言和日志

7.1 处理错误

7.1.1 异常分类

非检查型异常：Error和RuntimeException
检查型异常：其他异常

7.1.2 声明检查型异常

1.为什么：告诉编译器方法可能抛出异常
2.怎么办：throws语句

7.1.3 如何抛出异常 throw

7.1.4 创建异常类，继承合适的异常类，默认构造器和包含详细描述的构造器

7.2 捕获异常

7.2.1 捕获异常

1.try catch语句
2. 处理策略，自己处理或者继续传递
3.覆盖的超类方法如果没有抛出异常，那么必须自己处理

7.2.2 捕获多个异常

1.多cath语句
2.多异常语句从java7开始

7.2.3 再次抛出异常与异常链

1.将原始异常设置为此次异常的原因initCause
2.获取原始异常getCautse

7.2.4 finally子句

1.为什么：异常代码需要清理资源
2.特殊情况:finally中的return可能会覆盖掉方法本身的返回值

7.2.5 try-with-Resource 语句

1.关闭资源尽量使用这个语句，避免双层捕获，可以自动捕获close抛出的异常，通常会抑制close抛出异常，可以通过getSuppressed方法获取
2.java9可以使用外来资源

7.2.6 分析堆栈轨迹元素

1. throwable.printStackTrace打印堆栈轨迹的文本信息
2. StackWalker,生成一个StackWaler.Frame的栈帧流，然后通过遍历或者stream的方式进行处理

7.3 使用异常的技巧

1.异常处理不能代替简单测试
2.不要过分的细化异常
3.充分利用异常层次
4.不要压制异常
5.检测错误时，苛刻比放任好
6.不要羞于传递异常

7.4 使用断言

7.4.1 断言的概念 断言是在测试环境和调试下的一种战术性工具！

1.为什么：测试环境下，检测输入环境的正确性

7.4.2 启用和禁用断言 这是类加载器的功能,因此不能应用到没有类加载器的“系统类”上

//启用断言
java -enableassertions MyApp
//在某个类或者包中启用
java -ea:MyClass -ea:com.company.myLib MyApp
//禁用
java -disableassertions/-da ...

7.4.3 使用断言完成参数检查

1.使用断言的场景：前置条件检查

7.4.4 使用断言提供假设文档

7.5 日志 日志是一种程序整个生命周期都要使用的战略性工具

7.5.1 基本日志

7.5.2 高级日志

1.默认情况下只记录info以上的日志
2.可以使用logp方法活得调用类和方法的确切日志
3.可以使用entering或exiting来跟踪执行流
4.可以使用throwing和log记录抛出异常

7.5.3 修改日志配置

1.默认的日志配置文件位置 conf/loggin.properties

7.5.4 本地化

7.5.5 处理器

7.5.6 过滤器

7.5.7 格式化器

7.5.8 日志技巧

7.6 调试技巧

8 泛型程序设计

8.1为什么要使用泛型程序设计

8.1.1 类型参数的好处

1.可读性好
2.不用进行强制类型转换
3.有利于编译器进行类型检测

8.1.2 谁想成为泛型程序员

8.2 定义简单泛型类

8.3 泛型方法

8.4 类型变量的限定

1.限定类型使用&来分隔
2.java最多只能有一个类限定，并且必须是类型参数限定列表中的第一个

8.5 泛型代码和虚拟机

8.5.1 类型擦除 原始类型使用限定表中的第一个来替换类型变量

1.为了提高效率，标签接口应该放在最后，减少强转的必要

8.5.2 转换泛型表达式 泛型自动添加强转

8.5.3 转换泛型方法

1.泛型擦除会带来与多态的冲突，一般是擦除父类的类型参数导致，这可以通过桥方法解决
2.泛型擦除带来方法签名相同仅返回类型不同的情况，虚拟机可以自己处理，因为虚拟机通过返回类型+方法签名来确认调用方法。

8.5.4 调用遗留代码

8.6 限制与局限性

8.6.1 不能用基本类型实例化类型参数

8.6.2 运行时类型查询只适用于原始类型

8.6.3 不能创建参数化类型的数组 数组不会记录元素的泛型，因此不安全

8.6.4 Varargs 警告 @SafeVarargs

8.6.5 不能实例化类型泛型参数

需要实例化泛型的场景，可以通过两种方法来处理
1.让调用者提供一个构造器表达式
2.提供类，通过反射来构造

8.6.6 不能构造泛型数组

8.6.7 泛型类的静态上下文中类型变量无效

8.6.8 不能抛出或捕获泛型类的实例

1.不能使用泛型类扩展Throwable
2.catch子句中不能使用类型变量

8.6.9 可以取消对检查型异常的检查 可以用拍抛出run()方法中的检查型异常

8.6.10 注意擦除后的冲突

若两个类是同一接口的不同参数化，那么一个类或者类型变量就不能同时作为这两个类的子类。可能是由合成的桥方法冲突导致的。

8.7 泛型类型的继承规则

8.8 通配符类型

8.8.1 通配符概念

8.8.2 通配符的超限定

1.带有超类型的通配符允许写入泛型对象，带有子类型限定的通配符允许读取一个泛型对象

8.8.3 无限定通配符 无限定的set方法甚至不能用Object调用

8.8.4 通配符捕获：编译器必须能够保证通配符表示单个确定的类型

8.9 反射和泛型

8.9.1 泛型Class类

8.9.2 使用Class参数进行类型匹配

8.9.3 虚拟机中的泛型类型信息

8.9.4 类型字面量？

9 集合

12 并发

12.1什么是线程 CPU调度的基本单位

12.2线程状态

Java的6种线程状态

• New
• Runnable
• Blocked
• Waiting
• Time waiting
• Terminated

12.2.1 新建状态 new 出来，创建

12.2.2 可运行线程 调用了start()

12.2.3 阻塞和等待线程

等待锁->阻塞
等待通知（Object.wait或者Thread.join）-> 等待
等待超时参数 -> 计时等待

12.2.4 终止线程

12.3 线程属性

12.3.1 中断线程

1.interrupt方法只能请求终止线程
2.线程应当自己决定如何处理中断请求

12.3.2 守护线程 setDaemon

12.3.3 线程名

12.3.4 未捕获异常的处理器

12.3.5 线程优先级

12.4 同步

竞态条件：多个线程需要共享同一个数据的存取

12.4.1 竞态条件的一个例子

12.4.2 竞态条件详解

12.4.3 锁对象

12.4.4 条件对象

条件锁
当前线程在条件上调用await后会进入等待集，并放弃锁；当其他线程完成动作后，调用signalAll会通知等待集的线程进行条件检查，尝试重新测试条件

12.4.5 synchronized 关键字

synchronized 关键字的限制：
1.不能中断一个正在尝试获得锁的线程
2.不能指定尝试获得锁的超时时间
3.每个锁一个条件可能是不够的

12.4.6 同步块 又叫客户端锁定

12.4.7 监视器概念

12.4.8 volatile字段 能够保证各线程对volatile变量的可见性，但不保证原子性

12.4.9 final 变量 构造器完成构造后对其他线程才可见

12.4.10 原子性

1.cas操作
2.LongAdder和LongAccumulator类解决一个大量线程访问同一个变量进行累加带来的性能下降

12.4.11 死锁

常见的死锁情况：
1.资源不够分配，所以死锁
2.一次分配完成后，signal单独通知了一个不够分配的线程
https://blog.csdn.net/wljliujuan/article/details/79614019#五产生死锁的四个必要条件

12.4.12 线程局部变量

ThreadLocal和ThreadLocalRandom

12.4.13 为什么废弃stop和suspend方法

stop会导致数据的不一致
suspend可能会挂起带有锁的线程，这会导致死锁

12.5 线程安全的集合

12.5.1 阻塞队列

很多多线程问题可以通过阻塞队列来进行序列化

12.5.2 高效的映射、集和队列

12.5.3 映射条目的原子更新

compute/computeIfPresent/computeIfAbsent/merge

12.5.4 对并发散列的批操作

search/reduce/forEach

12.5.5 并发集视图

newKeySet/

12.5.6 写数组的拷贝？？？？？？？？

12.5.7 并行数组的算法

parallelSort/parallelSetAll/parallelPrefix

12.5.8 较早的线程安全集合

12.6 任务和线程池

12.6.1 Callable与Future

Callable 表示一个具有返回值的任务
Future 封装任务的返回值

12.6.2 执行器 Executors

12.6.3 控制任务组

invokeAny:提交所有对象并返回某个对象的结果
invokeAll:提交一个集合中的所有对象
ExecutorCompletionServcie:可以按照计算出结果的顺序来获得结果

12.6.4 fork-join框架

RecursiveTask/RecursiveAction

12.7 异步计算

12.7.1 可完成Future CompletableFuture

supplyAsync可以传入回调函数类似于前端的Promise
whenComplete可以用来处理结果和异常两种情况
complete可以显示的为其设置完成值
isDone 返回Future对象是否完成

12.7.2组合可完成Future

thenApply
thenApplySync在另外的线程中调用回调函数

12.7.3 用户界面回调中的长时间运行任务

跳过了，有兴趣再看

12.8 进程

12.8.1 建立一个进程

ProcessBuilder和Process
1.获取和配置输入输出流
2.配置进程的环境变量
3.建立进程交互的管道

12.8.2 运行一个进程

12.8.3 进程句柄

ProcessHandle