导图社区 职场必看！Java编程思想思维导图
- 5.2k
- 982
- 172
- 举报
职场必看！Java编程思想思维导图
如何从0逆袭Java编程大师？一张思想思维导图带你了解Java编程。本图共有二十一章，从各个方面为你提供解答，内容详见且条理清晰，注意从十七章后知识点等多，更详细，赶快收藏下图学习吧！！！
编辑于2018-12-20 07:05:26- 相似推荐
- 大纲
Java编程思想思维导图
第一章 对象导论
抽象过程
汇编语音
底层轻微抽象
命令式语言
C、BASIC
对汇编的抽象
解决问题时
基于计算机的结构
不会基于需要解决问题的结构
只针对待解决问题建模
世界某些特定视图
LISP
所有问题最终都是列表
APL
所有问题都是算法形成的
不能解决所有问题
面向对象OOP
表示问题空间的元素
不会受限于任何特定类型的问题
异常处理：处理错误
错误 ->置于编程语言中
Java内置异常处理并强制使用
每个对象都提供服务
把对象想象成‘服务提供者’
开发理解程序
提高内聚性，不试图做更多的事
被隐藏的具体实现
访问控制
让客户端程序员无法触及他们不应该触及的部分
允许类库设计者改变内部分工作方式
关键字
public
任何类都可以访问
protected
仅继承的类可以访问
default
仅同包目录下的类可以访问
private
仅自己能访问
复用具体实现
组合
现有类-->新的类
极大的灵活性
继承
编译器 -->继承类 -->编译时的限制
继承
父类和子类差异
直接在子类加方法
覆盖方法
每个对象一个接口
类
问题空间元素<-->解空间元素
接口
确定某一特定对象，所能发出的请求
伴随多态的可互换对象
特定类型 --> 父类对象
不能依赖特定类型的代码
函数调用
前期绑定
非面向对象编程
运行代码的绝对地址
后期绑定
面向对象编程
编译器-->确保调用方法的存在
运行时-->计算代码的地址
Java编译器
how?
对象中存储信息-->计算方法地址
动态绑定会默认的
C++需要virtual关键字
向上转型
单根继承结构
好处
保证所有对象具有某些功能
极大简化参数传递
容易实现垃圾回收
容器
集合
List
存储序列
Map
关联数组
Set
无重复集合
泛型
向下转型 -->Object -->具体类型
参数化类型
对象的创建和生命周期
C++
追求最大执行速度
编写时确定：存储空间和生命周期
存储
堆栈
静态存储区
Java
存储
堆的内存池
逻辑假设
“是一个”与“像是一个”的关系
是一个
继承至覆盖父类
纯粹替代
像一个
在子类中添加新的接口元素
第21章 并发
并发的多面性
并发方式
进程
操作系统级别
进程相互隔离
线程
Java支持
抢占式
更快的执行
多处理器、多个任务→提高吞吐量
↑运行在单处理器上的程序性能
阻塞
基本的线程机制
定义任务
实现Runnable接口，编写run()方法
加入一个线程
join()
使用Executor
客户端和任务执行间的间接层
允许管理异步执行的任务，无需显式管理线程的生命周期
shutdown()
防止新任务提交给Executor
当前线程继续允许之前提交的所有任务
newFixedThreadPool
预先执行代价高昂的线程分配
newCachedThreadPool
为每个任务创建一个线程
newSingleThreadExecutor
多个任务将排队
任务会顺序执行
所有任务使用相同的线程
序列化任务，不需要同步共享资源
Thread类
Runnable对象→Thread构造器
线程调度机制是非确定性的
早期JDK不会频繁对时间切片
休眠
sleep()
InterruptedException
优先级
线程的重要性→调度器
JDK 10个优先级
Windows 7个且不固定
只使用
MAX_PRIORITY
NORM_PRIORITY
MIN_PRIORITY
让步
yield()
后台(daemon)线程
在后台提供通用服务
不是程序中不可或缺的部分
所有非后台线程结束后，会杀死进程的所有后台线程
setDaemon()
从任务中产生返回值
Runnable不返回任何值
实现Callable接口
call()
ExecutorService.submit()调用
Future对象
共享受限资源
不正确地访问资源
EvenChecker
消费者任务
IntGenerator
EvenGenerator
解决共享资源竞争
why
你永远都不知道一个线程何时在运行
对资源加锁
序列化访问共享资源
互斥量-mutex
synchronized
流程
检查锁是否可用
获取锁
执行代码
释放锁
特定对象
所有方法共享一个锁
每个类
syn static 方法共享
一个任务可以多次获得对象的锁
同步控制EvenGenerator
显式的Lock对象
代码缺乏优雅性
更加灵活
更细粒度的控制
原子性与易变性
原子性
原子操作不能被线程调度机制中断
应用中的可视性
对volatile域修改
所有读操作能立刻看到修改
long和double
两个分离的32位操作
字撕裂
volatile
告诉编译器，不要执行任何读取和写入操作的优化
读取和写入直接针对内存，不被缓存
反例
原子类
AtomicInteger
AtomicLong
AtomicReference
compareAndSet(exp, update)
临界区
同步方法内部的部分代码，不是整个方法
synchronized指定某个对象，锁用来对花括号内的代码同步
（互斥量是同步整个方法）
ThreadLocal
根除对变量的共享
为相同变量的不同线程，创建不同存储
状态↔线程
代码
package Concurrency;<br><br>import java.util.Random;<br>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br>import java.util.concurrent.TimeUnit;<br><br>public class ThreadLocalVariableHolder {<br> private static ThreadLocal<<Integer> value = <br> new ThreadLocal<<Integer>() {...
终结任务
在阻塞时终结
线程状态
new 新建
Runnable 就绪
Blocked 阻塞
有某个条件阻止线程运行
调度器忽略线程
Dead 死亡
进入阻塞状态
调用sleep()
调用wait()线程挂起
等待某个输入/输出完成
试图在某对象调用同步方法，但对象锁不可用
中断
interrupt()
Executor-shutdownNow()
Executor.submit()返回Future，可调用cancel()
线程间的协作
概述
互斥-解决资源共享问题
协作-多个任务一起工作，解决某个问题
任务之间的握手
wait()和notifyAll()
wait()
等待某个条件发生变化，这个变化由另一任务实现
挂起线程，对象上的锁释放
sleep()和yield()没有释放锁！
将任务挂起，只有在notify()或notifyAll()才被唤醒
notify()
通知对象x
众多等待同一个锁的任务，只有一个被唤醒
错失的信号
死锁
生产者与消费者
Chef
生产者
WaitPerson
消费者
Meal
Restaurant
生产者-消费者与队列
wait()和notifyAll()是低级的任务操作，每次交互都握手
更高的抽象级别-同步队列
BlockingQueue
同一时刻只允许一个任务插入或删除元素
任务间使用管道输入/输出
PipedWriter
PipedReader
死锁
哲学家就餐
5个人，5根筷子，每个人2根筷子才能吃饭，但是一人只拿了1根
Chopstaicks
Philosopher
DeadlockingDining
死锁条件
互斥条件
任务的资源至少有一个是不能共享的（筷子）
持有资源
一个任务持有一个资源，等待另一个资源
资源不能被任务抢占
循环等待
新类库中的构件
CountDownLatch
同步一个或多个任务，强制它们等待由其他任务执行的一组操作
CyclicBarrier
一组任务并行执行，在进行下一个步骤前等待，直至所有任务都完成
所有的并行任务在栅栏处列队，一致地向前移动
DelayQueue
无界的BlockingQueue，放置实现了Delayed的接口对象
对象只能在到期时才能从队列取走
PriorityBlockingQueue
优先级队列，具有可阻塞的读取操作
Exchanger
两个任务交换对象的栅栏
性能调优
免锁容器
原理
对容器的修改可以与读取操作同时发生，只要读取者只能看到完成修改的结果
修改在容器数据结果的副本执行，在修改过程中不可视
CopyOnWriteArrayList
CopyOnWriteArraySet
ConcurrentHashMap
ConcurrentLinkedQueue
乐观加锁
保持数据未锁定状态
ReadWriteLock
优化不频繁写入，但多个任务经常读取的数据结构
如果写锁被持有，任何读取者都不能访问
总结
线程好处
轻量级的执行上下文切换（大约100条指令）
进程需要上千条指令，并改变所有内存空间
而线程只改变程序的执行序列和局部变量
多线程缺点
等待共享资源时，性能↓
处理线程，额外CPU
糟糕的程序设计，导致不必要的复杂度
病态行为：竞争、死锁
不同平台导致的不一致性
第4章 控制执行流程
恰好出现在迭代语句前
continue
继续当前的下一次循环
break
中断当前循环
continue label
继续循环→label处
break label
中断循环→label处
第5章 初始化和清理
用构造器确保初始化
作用
确保每个对象初始化
调用构造器，是编译器的责任
没有返回值
不是返回值为void
this关键字
问题
a.peel(1), b.peel(2)
如何知道是a还是b调用的peel方法？
答案
作为第一个参数→peel()
this-所操作对象的引用
类似于Banana.peel(a, 1)
清理：终结处理和垃圾回收
“特殊”内存
GC仅负责new出来的对象
“本地方法”分配的内存，GC无法回收
finalize()
GC前，调用finalize()
GC，回收对象内存
说明
对象可能不被垃圾回收
垃圾回收只与内存有关
绝对不能直接调用finalize()
对象的创建过程
首次创建Dog对象、访问Dog静态方法，Java解释器定位Dog.class
载入Dog.class，静态初始化
new Dog()时，在堆上分配空间
存储空间清零
基本类型→默认值
引用→null
执行字段定义处的初始化动作
执行构造器
初始化
静态初始化
static{}
首次加载类时执行（即使未生成类对象）
非静态初始化
{}
生成对象时执行，匿名内部类的初始化
构造器（最后执行）
枚举类型
enum类→编译器行为
特性
toString()
ordinal()
特定enum常量的声明顺序
values()
按顺序生成数组
第6章 访问控制权限
为什么控制访问权限？
1.使用户不触碰不该触碰的部分
2.更改内部实现，不影响客户端程序员
访问权限关键字
public
protected
继承的类+同包的类
default
同包的类
private
类的访问权限
可以
public
default
不可以（特例：内部类）
private
protected
第7章 复用类
如何复用？
组合
新类中，产生现有类的对象
继承
按照现有类型，进行复用
调用导出类，先加载基类
@Override
确保覆盖，而非重载
代理
继承和组合的中庸之道
成员对象→构造的类中（组合）
在新类中暴露成员对象的所有方法（继承）
在组合与继承之间选择
组合
显式：在新类中放置子对象
复用具体实现，而非接口
继承
隐式：在新类中放置子对象
新类→基类，复用接口
向上转型
新类是现有类的一种类型
类接口可能丢失方法
final关键字
数据
基本类型
引用
引用所指向的对象恒定不变
指向对象的内容，可以更改
参数
无法改变参数所指向的对象
方法
防止继承类覆盖
private方法隐式地为final的
无法获取→无法覆盖
类
无法被继承
Java的final类
基本类型的包装类
字符串
String
StringBuilder
StringBuffer
数学
Math
StrictMath
系统
System
Class
第8章 多态
对比
多态
分离：做什么↔怎么做，消除类型间的耦合关系
封装
合并：特征↔行为，创建新的数据类型
实现隐藏
分离：接口↔实现，将细节私有化
问题
基类的引用，如何找到继承类的方法？
答案
编译器不知道对象的类型
运行时判断对象的类型，找到正确的方法体
准则
继承：表达行为（方法）间的差异
组合：状态（对象）上的变化
第9章 接口
关系
普通类→抽象类→接口
抽象类和抽象方法
抽象方法
仅有声明，没有方法体
abstract void f()
抽象类
包含抽象方法的类
编译器阻止实例化
可以不包含抽象方法
阻止创建实例
重构工具
公共方法→继承层次向上移动
接口
含义
完全抽象的类
没有任何方法体
域
隐式：static, final
Java 5前，创建常量组的工具（enum）
不能是“空final”
可以被非常量表达式初始化
所有实现了特定接口的类，看起来都像这样
类与类之间的协议
作用
完全解耦
“忽略”继承层次
实现“多重继承”
接口的组合
为什么使用接口？
1.能向上转型为多个基类型
2.防止创建该类的对象
接口与工厂
工厂方法
工厂对象→创建方法
生成接口的某个实现的对象
好处
代码完全与接口的实现分离
透明地将某个实现，替换成另一个实现
第10章 内部类
private内部类
完全阻止依赖于类型的编码
完全隐藏了实现细节
无法访问不属于公共接口的方法
在方法和作用域内的内部类
为什么需要？
实现接口，创建并返回引用
创建类，不希望类公共可用
作用域和普通变量一样
匿名内部类
说明
返回值的生成，表示返回值的类的定义结合在一起！
通过new表达式，自动向上转型为接口的引用
类是匿名的，没有名字
构造器
无参
有参
特点
扩展类or实现接口，不能两者兼备
只能实现一个接口
工厂方法
使用匿名内部类
嵌套类
说明
static 内部类对象×外围类对象
不能从嵌套类的对象，访问非静态的外围类对象
接口内部的类
嵌套类→接口的一部分
接口中的任何东西，都是public和static的
好处
创建公共代码，被所有不同实现共用
为什么需要内部类
入口
内部类对象→访问外围类对象的所有成员
内部类→进入外围类的窗口
多重继承
每个内部类，独立继承一个（接口的）实现
外围类继承层次，对内部类无影响
内部类允许继承多个非接口类型
闭包与回调
回调
对象携带信息，在某一时刻调用初始对象
控制框架
图形用户接口 GUI
事件驱动系统
第11章 持有对象
容器
用途
保存对象
编译期×错误类型→容器
Collection
说明
独立元素的序列
槽内只有一个元素
分类
List
ArrayList
按照插入顺序
√随机访问元素
×中间插入和移除元素
LinkedList
按照插入顺序
√中间插入和移除元素
×随机访问元素
Stack
后进先出 LIFO
Set
元素不能重复
HashSet
散列函数→查询速度快
TreeSet
红黑树→排序
Queue
先进先出 FIFO→并发编程
PriorityQueue
Map
映射表：“键值对”对象
槽内有两个对象：键和与之关联的值
迭代器
统一了对容器的访问方式
只能单向移动
foreach隐形包括迭代器
第二章 一切都会对象
用引用操控对象
遥控器（引用）-->电视机（对象）
必须由你创建所有的对象
存储地点
寄存器
处理器的寄存器--速度最快
不能直接控制
堆栈
通用RAM中
java对象引用
堆
通用的内存池
Java对象
常量存储
程序代码内部
ROM(只读存储器)
非RAM存储
流对象
持久化对象
特例
基本类型
特例：基本类型
boolean
char
byte
shor
int
long
float
double
void
高精度数字
BigInteger
BigDecimal
Java中的数组
自动初始化
范围检查
少量内存开销
运行时下标检查
创建新的类型：类
类成员的基本数据类型初始化
非类字段 -->不初始化
永远不需要销毁对象
第13章 字符串
字符串
String
对象不可变
StringBuilder
非线程安全，可变
StringBuffer
线程安全
格式化输出
Formatter
正则表达式
Java
\\d
\\\\
一个\
其他语言
\d
第14章 类型信息
类型信息
Class对象→JVM类加载器
常用方法
printInfo()
全限定类名
getInterfaces()
包含的接口
getSuperclass()
直接基类
newInstance()
创建类
必须有默认构造器
初始化
对静态方法或非常数静态域的首次引用
static final 不初始化
构造器隐式为静态的
泛化的Class引用
Class
类型判断
x instanceof Integer
RTTI
含义
RunTime Type Info
运行时，识别对象的类型（多态）
编译时打开和检查.class文件
好处
代码只操纵基类的引用
方便扩展程序
反射
public class RT {<br> public static int a = 10;<br> <br> public void say(int a, String s) {<br> System.out.println(a);<br> System.out.println(s);<br> }<br> <br> public void run() {<br> System.out.println("Hello, run()");...
运行时加载类
磁盘中的文件
网络中的一串字节
java.lang.reflect
Field
Method
invoke调用
Constructor
动态代理
中间人→额外的操作
Java的动态代理
@Override<br> public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {<br> return null;<br> }
动态创建代理
动态处理代理方法的调用
所有调用→单一的调用处理器
代码耦合度，超过你的期望
第15章 泛型
public class HelloWorld {<br> public <<T> void f(T x) {<br> System.out.println(x.getClass().getName());<br> }<br> <br> public static void main(String[] args) {<br> HelloWorld helloWorld = new HelloWorld();<br> helloWorld.f("");<br> helloWorld.f(4);<br> helloWorld.f(4.0);...
引入原因
多态
方法的参数是接口
但是必须满足特定的接口
泛型
更通用→某种不确定的类型（接口）
参数化类型（容器类）
泛型
简单泛型
指定容器要持有什么类型
编译器→保证类型的正确性
元组类库
一次方法调用，返回多个对象
一个对象→持有多个对象
泛型接口
生成器，创建对象的类
泛型方法
泛型参数列表→返回值前
尽量使用泛型方法
擦除
在泛型代码内部，无法获得任何有关泛型参数类型的信息
泛型→具体类型信息→被擦除
边界
泛型的参数类型→设置限制条件
<T extends HasF>
限制为HasF的类型子集
<? super T>
超类型通配符（参数是下界）
某个特定类的任何基类
<?>
无界通配符
第16章 数组
为什么特殊？
效率
简单的线性序列
存储和随机访问对象引用序列
效率最高
类型
保存基本类型
泛型之前的容器不能
优先使用容器
更多的功能
编译期类型检查
效率已经不是问题
Arrays
fill()
填充各个位置
System.arraycopy()
复制数组
比for循环快很多
equals()
比较整个数组
元素个数
对应位置的元素
sort()
排序算法
基本类型
快速排序
引用类型
稳定归并排序
对象比较的方式
java.lang.Comparable接口
编写自己的Comparator
比较
当前对象<参数
负值
当前对=参数
0
当前对象>参数
正值
binarySearch()
排序数组→快速查找
第17章 容器深入研究
填充容器
Collections.nCopies()
Collections.addAll()
Set和存储顺序
Set
每个元素—唯一
元素必须定义equals()
HashSet
元素必须定义hashCode()
TreeSet
保持次序的set，底层为树结构
元素必须实现Comparable接口
方法
first()
返回容器的第一个元素
last()
返回容器的最末一个元素
subSet(from, to)
Set的子集
headSet(to)
<to的Set子集
tailSet(from)
≥from的Set子集
LinkedHashSet
内部使用链表维护插入的次序
元素必须定义hashCode()
理解Map
实现
HashMap
构造器（调整容器性能）
容量
负载因子
TreeMap
基于红黑树的实现
方法
firstKey()
lastKey()
subMap()
fromKey()
headMap()
tailMap()
LinkedHashMap
取得顺序是插入顺序
WeakHashMap
“弱键”，允许释放映射所指向的对象
如果映射外没有引用指向键，则键可以被GC
ConcurrentHashMap
线程安全
不涉及同步加锁
IdentityHashMap
性能
散列码
相对唯一，代表对象的int值
将对象的某些信息转换而成
散列Map，必须实现
equals()和hashCode()
覆盖equals()，总是同时覆盖hashCode()
hashCode()不需要返回唯一的标识码
equals()方法必须严格判断两个对象是否相同
散列与散列码
Object
hashCode()
使用对象的地址计算散列码
equals()
比较对象的地址
equals()
自反性
x.equals(x)=true
对称性
y.equals(x)=true→x.equals(y)=true
传递性
x.equals(y)=true,y.equals(z)=true→x.equals(z)=true
一致性
无论比较对少次，结果都是一样的
x!=null→x.equals(null)=false
理解hashCode()
目的
用一个对象→查找另一个对象
键对象→生成数字（散列码）→数组下标
bucket：实际散列表的数组命名
冲突
equals()方法→线性查询
put()
针对键hashCode()，转换取模
数组的对应位置
null
创建新的LinkedList
非null
list是否有相同元素
有→替换value
没有→添加到list末尾
get()
同put()
覆盖hashCode()
why?
无论何时，对同一个对象调用hashCode()→相同值
hashCode()→处理→桶位下标
how?
不能依赖易变的数据
数据变化→不同散列码
不能依赖具有唯一性的对象信息(this)
Apache库自动生成
HashMap性能因子
容量
桶位数
初始容量
创建时拥有的桶位数
尺寸
当前存储的项数
负载因子
尺寸/容量
空表
0
半满表
0.5
>负载因子，容器自动增加容量，再散列
构造器可以指定，默认0.75
同步控制
自动同步整个容器
synchronizedList()
快速报错
防止多进程同时修改同一容器
持有引用
引用
SoftReference
内存敏感的高速缓存
WeakReference
规范映射，不影响GC回收
对象的实例可以在程序多处同时使用，节省空间
PhantomReference
调度回收前的清理工作
WeakHashMap
保存WeakReference
value只保存一份实例→节省存储空间
Java 1.0/1.1 的容器
Vector
Hashtable
Stack
BitSet
第18章 Java I/O系统
概述
源端-接收端
文件
控制台
网络连接
通信方式
顺序
随机存取
缓冲
二进制
按字符
按行
按字
Preferences
key-value数据集合
基本类型
字符串
单个字符串长度8K
应用
存储和读取用户的偏好
程序配置项的设置
数据存储位置
不是本地文件
使用合适的系统资源
Windows的注册表
输入和输出
流
有能力产出数据的数据源对象
有能力接收数据的接收端对象
Java
输入
InputStream或Reader派生
read()
输出
OutputStream或Writer派生
write()
叠合多个对象→期望功能
InputStream
作用
表示从不同数据源产生输入的类
途径
字节数组
String对象
文件
管道
Internet连接
类型
ByteArrayInputStream
内存的缓冲区
StringBufferInputStream
String
FileInputStream
文件读取信息
PipedInputStream
SequenceInputStream
两个或多个InputStream合并为单一
FilterInputStream
抽象类
OutputStream
作用
输出所要去往的目标
目标
字节数组
文件
管道
类型
ByteArrayOutputStream
内存创建缓冲区
所有送往“流”的数据，都放于此
FileOutputStream
信息写至文件
PipedOutputStream
FilterOutputStream
抽象类
添加属性和接口
FilterInputStream从InputStream读取数据
DataInputStream
BufferedInputStream
LineNumberInputStream
PushbackInputStream
FilterOutputStream向OutputStream写入
DataOutputStream
PrintStream
格式化输出
BufferedOutputStream
Reader和Writer
InputStream和OutputStream
面向字节
8位，byte
Reader和Writer
面向字符
兼容Unicode
信息的来源和去处
InputStream
Reader
适配器
InputStreamReader
OutputStream
Writer
适配器
OutputStreamWriter
FileInputStream
FileReader
FileOutputStream
FileWriter
ByteArrayInputStream
CharArrayReader
ByteArrayOutputStream
CharArrayWriter
PipedInputStream
PipedReader
PipedOutputStream
PipedWriter
File类
表示
特定文件的名称
一个目录下的一组文件的名称
标准I/O
标准输入
System.in
未加工的InputStream
标准输出
System.out
printStream对象
标准错误
System.err
printStream对象
进程控制
Java内部→其他操作系统程序
OSExecute.command()
传递command字符串
新I/O
JDK 1.4
速度提高
通道、缓冲器
修改类
FileInputStream
FileOutputStream
RandomAccessFile
压缩
属于InputStream和OutputStream继承层次
压缩类库按字节方式，不是字符方式
Java档案文件
JAR
Java ARchive
跨平台
一组文件→单个压缩文件
压缩，传输时间短
向服务器发一次请求
对象序列化
意义
创建对象，程序终止时，保存状态
自动弥补操作系统的差异
方法
实现Serializable接口
对象→字节序列
字节序列→原来的对象
轻量级持久化
对象必须显式序列化
显式反序列化
支持特性
远程方法调用RMI
存活于其他计算机的对象
像存活于本机一样
Java Beans
配置状态信息
方法
序列化
创建OutputStream对象
封装在ObjectOutputStream对象中
调用writeObject()即可对象序列化
反序列化
将InputStream封装在ObjectInputStream内
调用readObject()
transient关键字
特定子对象，不想Java序列化保存
逐个字段关闭序列化
只能和Serializable对象配合使用
XML
对象序列化限制
仅是Java的解决方案
只有Java程序能反序列化这种对象
优点
跨平台
跨语言
I/O流的典型使用
缓冲输入文件
基本的文件输出
第19章 枚举类型
简介
具名的值的有限集合→新的类型
作为常规的程序组件使用
基本enum特性
values()
enum实例的数组
ordinal()
enum实例在声明时的次序
从0开始
name()
实例声明的名字
向enum添加新方法
定义方法时，enum实例序列最后要加分号
enum不能被继承，剩下就像普通类
使用接口组织枚举
在接口内部，创建实现该接口的枚举→枚举分组
常量相关的方法
为enum实例编写方法→不同的行为
第20章 注解
概述
元数据、源代码文件结合在一起
有关程序的额外信息
注解处理器
读取注解的工具
内置注解
@Override
当前方法覆盖超类的方法
@Deprecated
使用该元素，会发出警告
@SuppressWarnings
关闭不当的编译期警告信息
元注解
专门负责创建新的注解
@Target
表示注解可以用在什么地方
ElementType
CONSTRUCTOR
构造器声明
FIELD
域声明
LOCAL_VARIABLE
局部变量声明
METHOD
方法声明
PACKAGE
包声明
PARAMETER
参数声明
TYPE
类、接口（包括注解类型）或enum声明
优点
减轻编写“样板”代码的负担
更加干净易读的代码
编译期类型检查
@Documented
注解包含在Javadoc中
@Inherited
允许子类继承父类中的注解
提取注解
已知实现类
Class：类定义
Constructor：构造器定义
Field：累的成员变量定义
Method：类的方法定义
Package：类的包定义
方法
getAnnotation:返回元素上指定类型的注解，如果该类型注解不存在，则返回null。
getAnnotations():返回该程序元素上存在的所有注解。
isAnnotationPresent:判断该程序元素上是否包含指定类型的注解，存在则返回true，否则返回false.
getDeclaredAnnotations():返回存在于此元素的所有注解
@Rectetion
在什么级别保存注解信息
RetentionPolicy
SOURCE
注解被编译期丢弃
CLASS
注解在class文件中可用，但会被VM丢弃
RUNTIME
VM运行期也保留注解
可用通过反射机制读取注解信息
第12章 异常
异常处理的优点之一，就是它使得你可以在某处集中精力处理你要解决的问题，而在另一处处理你编写代码产生的错误。<br><br>Java坚定地强调将所有的错误都以异常形式报告的这一事实，正是它远超过注入C++这类语言的长处之一。
发现错误
编译阶段
运行时
好处
提供一致的错误报告模型
节省代码
正常逻辑↔错误逻辑
Throwable
Error
JVM报告系统错误
Exception
编译期检查
RuntimeException
运行时异常
可忽略，防止代码臃肿
try-catch-finally
catch
仅处理匹配的catch子句
派生类对象，可以匹配基类
finally
子句总会执行
即使try中有return！
基本异常
构造器
默认
字符串参数
用名称代表发生的问题
根类
Throwable
printStackTrace()
从方法调用处→异常抛出处的方法调用序列
标准错误流
栈底：第一个方法调用