2.1面向对象编程基础

	面向过程	面向对象
区别	事物比较简单，可以用线性的思维去解决	事务比较复杂，使用简单的线性思维无法解决

共同点
二者相辅相成，并不是对立的
解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂关系，方便我们分析整个系统；
具体到围观操作，任然使用面向过程来处理

2.1.1对象和类的概念

对象：是具体得事务
类：是对对象的抽象
先有具体的对象，然后抽象各个对象之前像的部分，归纳出类通过类再认识其他对象。

在代码中
类：class
对象：实例

对象和类的关系
特殊到一般，具体到抽象
类可以看成一类对象的模板，对象可以看成该类的一个具体实例
类是用于描述统一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的动态和动态属性
JDK提供了很多类供编程人员使用，编程人员可可以定义自己的类

定义类（类的组成）
属性
方法
构造方法
代码块 静态代码块 内部类

创建对象
类名 对象名 = new 类名（）；

调用类的属性和方法
对象名.成员变量
对象名.成员方法

2.1.2类的属性

属性，又称成员变量
属性用于定义该类或该类对象包含的数据或静态属性
属性作用范围是整个类体
属性定义格式
[修饰符] 属性类型 属性名 = [默认值]

在定义成员变量时可以对其初始化
如果不对其初始化，Java使用默认的值对其初始化

基本类型	默认值
boolean	False
char	‘\u0000’(null)
byte	(byte)0
shoort	(short)0
int	0
long	0L
float	0.0f
double	0.0

局部变量和成员变量 区别

区别	成员变量	局部变量
声明位置不同	类中	方法中
作用范围不同	当前类的方法	当前方法
内存存放的位置不同	栈	堆
默认值	有	无

2.1.3引用类型

Java语言中除基本类型之外的变量类型都称之为引用类型

Java中对象和数组是通过引用对其操作的
引用可以理解为一种受限的指针
指针是可以进行与整数做加减运算的，两个指针之前可以进行大小比较运算和相减运算。引用不行，只能进行赋值运算
引用就是一个变量或对象的别名（引用的本质是一个对象）；指针是一个段内存空间的地址（指向存储一个变量值的空间或一个对象的空间）

栈
存放局部变量
先进后出，自下而上存储
方法执行完毕，自动释放空间

堆
存放new出来的对象
需要垃圾回收器来回收

方法区
存放 类的信息（代码）、static变量、字符串常量等

2.1.4构造器

构造器定义：constructor构造方法
一个创建对象时被自动调用的特殊方法

构造器作用：
为对象进行初始化工作

构造器是一种特殊的方法
构造器的方法名必须和类名一致
构造器虽然有返回值，但是不能定义返回类型（返回值得类型肯定是本类），不能在构造器里调用return
通过new关键字调用
如果没有定义构造器，则系统会自动定义一个无参的构造方法，如果已经定义则编译器不会添加无参数构造方法
与普通方法一样，构造方法可以重载

2.1.5方法调用

形参和实参
定义方法的参数是形式参数
调用方法的参数是实在参数
调用方法时要求参数个数相同，类型兼容

参数传递
基本数据类型的参数传递
无法通过方法调用改变变量的值
引用数据类型的参数传递
可以通过方法调用改变变量的值

2.1.6this关键字

this的作用
this表示的是当前对象本身
更准确地说，this代表当前对象的一个引用

普通方法中使用this
区分类成员属性和方法的形参
调用当前对象的其他方法（可以省略）
位置：任意

构造方法中使用this
使用this来调用其它构造方法
位置：必须是第一条语句

this不能用于static方法

2.1.7static关键字

在类中，用static声明的成员变量为静态成员变量，或者叫做：类属性，类变量
它为改类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显示初始化
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享
可以使用“对象.类属性”来调用。不过，一般都是使用“类名.类属性”
static变量治愈方法区中

用static声明的方法为静态方法
不需要对象，就可以调用（类名.方法名）在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员
静态方法不能以任何方式引用this和super关键字

2.1.8静态代码块

如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块
类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static代码块经常用来进行static变量的初始化
是在类初始化时执行，不是在创建对象时执行
静态初始化块中不能访问非static成员

2.1.9package

为什么需要package
为了解决类之间的重名问题
为了便于管理类，合适的类位于合适的包

package怎么用
通常是类的第一句非注释性语句
包名：域名倒着写即可，再加上模块名，并与内部管理类

注意事项
写项目时都要加包，不要使用默认包

2.1.10JDK中的包

Java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能

Java.awt
包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUL）

Java.net
包含执行与网络相关的操作的类

Java.io
包含能提供多种输入/输出功能的类

Java.util
包含一些使用工具类，如定义系统特性、使用与日期日历相关的函数

2.1.11 import

为什么需要import
如果不使用import，我们如果用到其它的包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其它包下面的类，从而可以在本类中直接通过类名来调用

import怎么使用
import Java.util.Date；
import Java.util.*；//导入该包下所有的类。会降低编译速度，但不会降低运行速度

注意要点：
Java会默认导入Java.lang包下所有的类，因此这些类我们可以直接使用
如果导入两个同名的类，只能用包名+类名来显示调用相关类
Java.util.Date date = new java.util.Date();

2.1.12import static

静态导入的作用：用于导入指定类的静态属性
JDK1.5后增加

如何使用
import static java.lang.Math.PI;//导入Math类的PI属性
然后，可以在程序中直接使用：System.out.println(PI);

2.2面向对象编程

2.2.1面向对象三大特征

继承 inheritance
子类 父类
子类可以从父类继承属性和方法
子类可以提供自己单独的属性和方法

封装 encapsulation
对外隐藏某些属性和方法
对外公开某些属性和方法

多态 polymorphism
为了适应需求的多种变化，是代码变得更加通用

面向过程只有封装性（功能的封装，而没有数据的封装），没有继承和多态

2.2.2封装

为什么需要封装？封装的作用和含义？

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性

程序设计追求“高内聚，低耦合”
高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用

2.2.3使用访问控制符，实现封装

成员（成员变量或成员方法）访问权限共有四种：
public 公共的
可以被项目中所有的类访问。（项目可见性）

protected 受保护的
可以被这个类本生访问，同一个包中的所有其他的类访问；被它的子类（同一包以及不同包中的子类）访问

default/friendly 默认的/友好的（包可见性）
被这个类本身访问，被同一个包中的类访问

private 私有的
只能被这个类本身访问。（类可见性）

类的访问权限只有两种
public 公共的
可被同一项目中所有的类访问。（必须与文件同名）
default/friendly 默认的/友好的
可被同一个包中的类访问

	同一个类	同一个包	子类	所有类
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

封装要点
类的属性的处理
一般使用private（除非本属性确定会让子类继承）
提供相应的get/set方法类访问相关属性，这些方法通常是public，从而提供对属性的读取操作。
（注意：boolean变量的get方法是用：is开头）
一些只用于本类的辅助性方法可以用private
希望其他类调用的方法用public

2.2.4继承

类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模
提高代码的复用性
extends意思是“扩展”。子类是父类的扩展
不同的叫法：超类、父类、基类、子类、派生类

通过继承可以简化类的定义，实现代码地重用
子类继承父类的成员变量和成员方法，但不能继承父类的构造方法
Java中只有单继承，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
Java中的多继承，可以通过接口来实现
如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object

2.2.5方法的重写（override）

在子类中可以根据需要对从基类继承来的方法进行重写
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型
重写方法不能使用比被重写方法更严格地访问权限（由于多态）

Object类是所有Java类的根基类
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

重写：toString方法：
默认返回：包名+类名+@+哈希码（根据对象内存位置生成，唯一不重复）
可以重写

2.2.6super关键字

super是直接父类对象的引用
可以通过supper来访问父类中被子类覆盖的方法或属性

2.2.7继承深化

父类方法的重写
”=“：方法名、形参列表相同
”<=“：返回值类型和异常类型，子类小于等于父类
”>=“：访问权限，子类大于等于父类

构造方法调用顺序
根据super的说明，构造方法第一句总是：super()来调用父类对应的构造方法
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止

2.2.8 对象的比较

==
比较两基本类型变量的值是否相等
比较两个引用类型的值即内存地址是否相等，即是否指向同一对象

equals（）
两对象的内容是否一致

自定义类必须重写equals（），否则其对象比较结果总是false

2.2.9 多态

多态性时OOP中一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性

Java中如何实现多态？使用多态的好处？

引用变量的两种类型
编译时类型（模糊一点，一般是一个父类）
由声明时的类型决定
运行时类型（运行时，具体是哪个子类就是哪个子类）
由实际对应的对象类型决定

多态窜在的3个必要条件
要有继承、方法的重写、父类引用指向子类对象

2.2.10 引用数据类型的类型转换

子类转换为父类：自动转换
上转型对象不能操作子类新增的成员变量和方法
上转型对象可以操作子类继承或重写的成员变量和方法
如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法

父类转换为子类：强制转换

2.2.11 final关键字

final可以用来修饰变量，方法，类
修饰变量：变量一旦被初始化便不可改变，相当定义一常量

修饰方法：final方法是在子类中不能被覆盖的方法

修饰类：fina类是无法被任何类继承

2.2.12 抽象类

为什么需要抽象类？如何定义抽象类？
是一种模板模式。抽象类为所有子类提供了一个通用模板，子类可以在这个模板基础上进行扩展
通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用

抽象方法和抽象类均必须用abstract来修饰
抽象方法没有方法体，只需要声明不需实现

有抽象方法的类只能定义成抽象类
相反抽象类里面的方法不一定全是抽象方法，也可以没有抽象方法

抽象类可以包含属性、方法、构造方法
抽象类不能实例化，即不能用new来实例化抽象类，只能用来被子类调用。
抽象类只能来继承
抽象方法必须被子类实现。抽象类的子类必须覆盖所有的抽象方法才能被实例化，否则还是抽象类

2.2.13 接口

为什么需要接口？接口和抽象类的区别？
接口就是比”抽象类“还”抽象“的”抽象类“，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离

接口就是规范，定义的就是一组规则，体现了现实世界中”如果你是…则必须能…“的思想。

接口的本质是契约，指定好后都遵循

接口的具体需求是多变的，必须以不变应万变才能从容开发。因此开发项目往往都是面向接口编程

接口相关规则
接口中所有方法都是抽象的
即使没有显式的将接口中的成员用public标示，也是public访问类型
接口中变量默认用public static final标示，所以接口中定义的变量就是全局静态常量

可以定义一个新接口，用extends去继承一个已有的接口
可以定义一个类，用implements去实现一个接口中所有方法
可以定义一个抽象类，用implements去实现一个接口中部分方法

如何定义接口？
格式
[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {
常量定义 public static final
方法定义 public abstract
}

如何实现接口
子类通过implements来实现接口中的规范
接口不能创建实例，但是可以用于声明引用变量类型
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的
Java 的类只支持单继承，接口支持多继承

C++支持多重继承，Java支单重继承
C++多重继承的危险性在于一个类可以继承了同一个方法的不同实现，会导致系统崩溃
Java中，一个类只能继承一个类，但同时可以实现多个接口，既可以实现多重继承的效果和功能，也避免了多重继承的危险性

注意：extends 必须位于implements之前

2.2.14 内部类

将一个类定义置入另一个类定义中就叫做”内部类“
类中定义的内部类特点
内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），反之则不行
内部类作为外部类成员，可声明为private、默认、protected或public
内部类成员只有在内部类的范围之内是有效的
用内部类定义在外部类中不可访问的属性。这样就再外部类中实现了比外部类的private还要小的访问权限
编译后生成两个类：OuterClass.class和OuterClass$innerClass.class

内部类分类
成员内部类 静态内部类 方法内部类 匿名内部类

匿名内部类
可以实现一个接口，或者继承一个父类
只能实现一个接口
适合创建那种只需要一次使用的类，不能重复使用。比较常见的是在图形界面编程GUI里用到
匿名内部类要使用外部类的局部变量，必须使用final修饰该局部变量

2.2.15垃圾回收机制

对象空间的分配
使用new关键字创建对象即可

对象空间的释放
传统的C/C++语言，需要程序呀U呢负责回收已经分配内部。显示回收垃圾回收的缺点
程序忘记及时回收，从而导致内存泄露，降低系统性能
程序错误回收程序核心类库的内存，导致系统崩溃

Java语言不需要程序呀U呢直接控制内存的回收，是由JRE在后台自动回收不再使用的内存，称为垃圾回收机制(Garbage Collection)
可以提高编程效率
保护程序的完整性
其开销影响性能。java虚拟机必须跟踪程序中有用的对象，确定哪些是无用的

垃圾回收机制关键点
垃圾回收机制只回收JVM堆内存里的对象空间
对其它物理连接，比如数据库连接、输入输出流、Socket连接无能为力
现在的JVM有多种垃圾回收实现算法，表现各异
垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行
可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象
程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行回收依然不确定
垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）
永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用

2.3数组

数组是相同类型数据的有序集合
相同类型的若干个数据，按照一定先后次序排列组合而成
其中，每一个数据称作为一个数组元素
每个数组元素可以通过一个下标来访问它们

数组特点
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括扩基本类型和引用类型

数组属于引用类型

2.3.1创建数组

一维数组的声明方式有两种
type[] arr_name;
type arr_name[];

java中使用关键字new创建数组对象
int[] s = new int[10];

2.3.2数组初始化

动态初始化
数组定义与数组元素分配空间并赋值的操作分开进行
　
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
格式： 类型[] 数组名 = {元素1，元素2…}

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

2.3.3数组的界限

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素
数组运算的引用方式：arrayName[index]
index为数组元素下标，可以是整型常量或整型表达式。
数组元素下标从0开始；长度为n的数组合法下标取值范围：0~n-1
每个数组都有一个属性length指明它的长度
起点和终点
起点：数组名[0]
终点：数组名[length-1]

2.3.4二维数组

Java中多维数组不必是规则矩阵形式

二维数组可以看成以数组为元素的数组
Java中多维数组的声明和初始化应按从高维到低维的顺序

2.3.5二维数组初始化

int a[][] = {{1},{2,3},{4,5,6}}
int b[][] = new int[3][5]
b[0] = new int[2]

2.3.6数组的拷贝

使用java.lang.System类的静态方法
public static void arraycopy（Object src,int srcPos,Object dest,int destPos,int length）
可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置
如果源数据数目超过目标数组边界会抛出indexOutOfBoundsException异常

2.3.7命令行参数

java应用程序的主方法（程序的入口）
public static void main（String args[]）{}

命令行参数
在启动Java应用程序时可以一次性地向应用程序中传递0~多个参数—命令行参数
命令行参数使用格式
Java ClassName aaa bbb “cc c”
由参数args接收
空格将参数分开
若参数包含空格，用双引号引起来

2.3.8java.util.Arrays

该类提供了关于数组操作的API
打印数组 toString方法
比较两个数组是否相同 equals方法
数组排序 sort方法
数组查找 binarySearch方法

2.4Java常用类

2.4.1基本数据类型和包装类

为什么需要包装类
Java并不是纯面向对象的语言。Java语言虽然是面向对象地语言，但是Java中地基本数据类型却不是面向对象的。但是在实际使用中经常需要将基本数据转换为对象，便于操作。

包装类均位于java.lang包，包装类和基本数据类型的对应关系

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
Int	Integer
long	Long
float	Float
double	Double

包装类的作用
提供：字符串、基本数据类型、对象之间互相转换的方式
包含每种基本数据类型的相关属性如最大值、最小值等

所有包装类都有类似的方法，掌握一个其他都可以学会

包装类的基本操作（3方）
基本类型、字符串类型、包装类型

自动装箱
基本类型会自动地封装到与它相同类型的包装中
本质上是，编译器编译时调用valveOf方法

自动拆箱
包装类对象自行转换成基本数据类型
本质上，编译器编译时调用了XXXValue()方法

2.4.2 String

java字符串就是Unicode字符序列

Java允许使用符号"+"把两个字符串连接起来

String类常用方法
char charAt(int index)
返回字符串中第index个字符

boolean equals(String other)
如果字符串与other相等，返回true

boolean equalslgnoreCase(String other)
如果字符串与other相等（忽略大小写），则返回true

int indexOf(String str) lastIndexOf()
int length()
返回字符串的长度

String length()
返回字符串的长度

String replace(char oldChar,char newChar)
返回一个新字符串，它是通过用newChar替换此字符串中出现的所有oldChar而生成的

boolean startsWith(String prefix)
如果字符串以prefix开始，则返回true

boolean endsWith(String suffix)
如果字符串以suffix结尾，则返回true

String substring(int beginIndex)

String substring(int beginIndex,int endIndex)
返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所有字符

String 同LowerCase()
返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母

String toUpperCase()
返回一个新字符串，该串将原始字符串中所有小写字母改成大写字母

String trim()
返回一个新字符串，该串删除了原始字符串头部和尾部的空格

字符串相等的判断(一般使用equals方法)
equals判断字符串值相等，==判断字符串对象引用相等

2.4.3 StringBuffer和StringBuilder

StringBuffer和StringBUilder非常类似，均代表可变的字符序列，而且方法也一样

字符串选用
String：不可变字符序列
StringBuilder：可变字符序列、效率高、线程不安全
StringBuffer：可变字符序列、效率低、线程安全

String使用陷阱
使用+后原来的字符串对象会被丢弃，多次执行后，导致大量副本字符串对象留在内存中，降低效率。如果操作放到循环中，会极大影响程序的性能

2.5 时间处理相关类

2.5.1 Date时间类（java.util.Date）

在标准java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒
Java中时间的表示也是数字，是从 标准纪元1970年1月1号0点开始到某个时刻的毫秒数，类型是long

2.5.2 DateFormat和SimpleDateFormat

完成字符串和时间对象的转化
format(“日期”)
parse(“字符串”)

2.5.3 Calendar日历类

通过Calendar将人类对于时间的认识与计算机中的数字结合起来

2.5.4 GregorianCalendar公历

GregorianCalendar是Calendar的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统

注意：
月份：一月是0，二月是1…
星期：周日是1，周一是2…

2.6 Math类

包含了常见的数学运算函数

random() 生成[0,1)之间的随机浮点数
生成：0~10之间的任意整数
int a = (int)(10*Math.random());

生成：20~30之间的任意整数
int b = 20 + (int)(10*Math.random())

2.7 枚举

只能够取特定值中的一个
使用enum关键字
所有的枚举类型隐性地继承自java.lang.Enum
枚举实质上还是类，而每个被枚举的成员实质就是一个枚举类型的实例，它们默认都是public static final的。可以直接通过枚举类型名直接使用它们

定义一组常量时，使用枚举类型
尽量不使用枚举的高级特性，事实上高级特性都可以使用普通类来实现，没有必要引入复杂性

2.8 File类

文件和目录路径名的抽象表示形式。一个File对象可以代表一个文件或目录

可以实现获取文件和目录属性等功能

可以实现对文件和目录的创建、删除等功能

File不能访问文件内容

路径可以是绝对路径和相对路径，分隔符最好用File.separator

通过File对象可以访问文件的属性

通过File对象创建空文件目录
public boolean createNewFile()throws IOException
public boolean delete()
public boolean mkdir(),mkdirs()

2.9 异常机制

2.9.1异常

生活中异常

程序中异常
解决方式1：有开发者通过if-else来解决异常问题
代码臃肿：业务代码和异常处理代码放一起
程序员要花很大精力“堵漏洞”
程序员很难堵住所有“漏洞”

解决方式2：
开发者需要if-else来解决异常问题，而是Java提供异常处理机制。它将异常处理代码和业务代码分离，使程序更优雅，更好地容错性，高健壮性

异常（Exception）就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序

当Java程序出现异常时，就会在所处的方法中产生一个异常对象。这个异常对象包括异常的类型，异常出现时程序的运行状态以及对该异常的详细描述

Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

捕获异常
try 执行可能产生异常的代码
catch 捕获异常
finally 无论是否发生异常，代码总能执行

声明异常
throws 声明方法可能要抛出的各种异常

抛出异常
throw 手动抛出异常

2.9.2异常处理

try-catch
情况1：try块中代码没有出现异常
不执行catch块代码，执行catch块后边的代码

情况2：try块中代码出现异常，catch中异常类型匹配（相同或者父类）
执行catch块代码，执行catch块后边的代码

情况3：try块中代码出现异常，catch中异常类型不匹配
不执行catch块代码，不执行catch块后边的代码，程序会中断运行

注意
出现异常后，Java会生成相应的异常对象，Java系统，寻找匹配的catch块，找到后将异常对象付给catch块异常参数

出现异常后，try块中尚未执行的语句不会执行
出现异常并处理后，catch后面的语句还会执行

catch块中处理异常
输出用户自定义异常信息
调用异常对象的方法输出异常信息
继续向上抛出异常

异常类型

方法名	说明
Exception	说明
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	常识访问null对象成员
ClassNotFoundException	不能加载所需的类
InputMismatchException	欲的带数据类型与实际输入类型不匹配
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常

try-catch-finally
在try-catch块后加入finally块，可以确保无论是否发生异常，finally块中的代码总能被执行
无异常 try-finally
有异常 try-catch-finally

通常在finally中关闭程序块已打开的资源

finally块中语句不执行的唯一情况
异常处理代码中执行System.exit(1)退出Java虚拟机

finally块的具体执行过程
执行try或catch中代码
遇到return/throw，先执行finally中语句块
执行return/throw

多重catch
一段代码可能会引发多种类型的异常
当引发异常时，会按顺序来查看每个catch语句，并执行第一个与异常类型匹配的catch语句
执行其中一条catch语句后，其后catch语句将被忽略
在安排catch语句的顺序时，首先应该捕获最特殊的异常，然后再逐渐一般化，即先子类后父类

2.9.3异常分类

Error
Error类层次描述了Java运行时系统内部错误和资源耗尽错误，一般指与JVM或动态加载相关的问题，如虚拟机错误，动态链接失败，系统崩溃等

这类错误是无法控制的，同时也是非常罕见的错误。所以在编程中，不去处理这类错误

打开JDK包：java.lang.Error，查看它的所有子类

Exception
所有异常类的父类，其子类对应了各种各样可能出现的异常事件

Exception分类
所有异常类的父类，其子类对应了各种各样可能出现的异常事件

Exception分类
运行时异常RuntimeException（unchecked Exception）
可不必对其处理，系统自动检测处理
一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大

检查异常Checked Exception
必须捕获进行处理，否则会出现编译错误

注意：只有Java提供了Checked异常，体现了Java的严谨性，提高了Java的健壮性。同时也是一个备受争议的问题

2.9.4异常处理

声明异常throws
当Checked Exception产生时，不一定立刻处理它，可以再把异常Throws出去

如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间用逗号隔开

子类声明的异常范围不能超过父类声明范围
父类没有声明异常，子类也不能
不可抛出原有方法抛出异常类的父类或上层类

手动抛出异常throw
Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要手工创建并抛出

在捕获一个异常前，必须有一段代码先生成异常对象并把它抛出。这个过程我们可以手工做，也可以由JRE来试下，但是他们调用的都是throw子句

注意抛出运行时异常和Checked异常的区别
抛出Checked异常，该throw语句要么处于try块中，要么方法签名中有throws抛出
抛出运行时异常，没有要求

2.9.5自定义异常

在程序中，可能会遇到任何标准异常类都没有充分描述清楚的问题，这种情况下可以创建自己的异常类

从Exception类或者它的子类派生一个子类即可

2.10 容器

2.10.1集合

当需要将一些相同结构的个体整合在一起时，就可以考虑使用集合了

为什么使用集合而不是数组
集合和数组相似点
都可以存储多个对象，对外作为一个整体存在

数组的缺点
长度必须在初始化时指定，且固定不变
数组采用连续存储空间，删除和添加效率低下
数组无法直接保存映射关系
数组缺乏封装，操作繁琐

集合架构
Java集合框架提供了一套性能优良、使用方便地接口和类，它们位于java.util包中

Collection接口存储一组不唯一，无序的对象
List接口存储一组不唯一，有序（索引顺序）的对象
Set接口存储一组唯一，无序的对象
Map接口存储一组键值对象，提供key到value的映射
key 唯一 无序
value 不唯一 无序

2.10.2 Llist

List
特点：有序 不唯一（可重复）
ArrayList线性表中的顺序表
在内存中分配连续的空间，实现了长度可变的数组
优点：遍历元素和随机访问元素的效率比较高
缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低

LinkList 线性表中双向链表
采用双向链表存储方式
缺点：遍历和随机访问元素效率低下
优点：插入、删除元素效率比较高（但是前提也是必须先降低效率查询才可。如果插入删除发生在头尾可以减少查询次数）

List常用方法
List相对Collection增加了关于位置操作的方法

List的遍历方法
for
for-each
iterator迭代器

面向接口编程
List list = new ArrayList();
ArrayList list = new ArrayList();

集合中内容是否相同
通过equals进行内容比较，不是==引用比较

2.10.3 Set

Set
特点：无序 唯一（不重复）

HashSet
采用Hashable哈希表存储结构
优点：添加速度快 查询速度快 删除速度快
缺点：无序

LinkedHashSet
采用哈希表存储结构，同时使用链表维护次序
有序（添加顺序）

TreeSet
采用二叉树（红黑树）的存储结构
优点：有序 查询速度比List快（按照内容查询）
缺点：查询速度没有HashSet快

Set常用方法
Set相对Collection没有增加任何方法

Set的遍历方法
for-each
Iterator迭代器
无法使用for进行遍历（因为无序，所有没有get(i)）

HashSet、HashMap或Hashable中对象唯一性判断
重写其hashCode()和equals()方法

TreeSet中指明排序依据
实现Comparable接口
创建实现Compator接口的类

2.10.4 Map

Map
特点 key-value映射

HashMap
key 无序 唯一（Set）
value 无序 不唯一（Collection）

LinkedHashMap
有序的HashMap 速度快

TreeMap
有序 速度没有hash快

Set和Map关系
采用了相同的数据结构，只用于map的key存储数据，就是set

2.10.5 Iterator

所有集合类均未提供相应的遍历方法，而是把遍历交给迭代器完成。迭代器未集合而生，专门实现集合遍历

Iterator是迭代器设计模式的具体实现

Iterator方法
boolean hasNext()：判断是否存在另一个可访问的元素
Object next()：返回要访问的下一个元素
void remove()：删除上次访问返回的对象

可以使用Interator遍历的本质是什么
实现Iterable接口

for-each循环
增强for循环，遍历array或Collection的时候相当简单
无序获得集合和数组长度，无需使用索引访问元素，无需循环条件
遍历集合时底层调用Interator完成操作

for-each缺陷
数组
不能方便的访问下标值
不要在for-each中尝试对变量赋值，只是一个临时变量
集合
与使用Iterator相比，不能方便地删除集合中的内容

除了简单遍历并读出其中的内容外，不建议使用增强for

ListIterator与Iterator的关系
public interface ListIterator extends Iteratot
都可以遍历List

ListIterator与Iterator的区别
使用范围不同
Iterator可以应用于更多的集合，Set、List和这些集合的子类型
而ListIterator只能用于List及其子类型

遍历顺序不同
Iterator只能顺讯向后遍历;listIterator号可以逆向遍历
Iterator可以在遍历的过程中remove；ListIterator可以在遍历的过程中remove、add、set
ListIterator可以定位当前的索引位置，nextIndex（）和previousIndex（）可以实现。Iterator没有此功能。

2.10.6泛型

起因
JDK1.4以前类型不明确
装入集合的类型都被当成Object对待，从而失去自己的实际类型
从集合中取出往往需要转型，效率低，容易产生错误

解决办法
泛型，在定义集合的时候同时定义集合中对象的类型

好处
增强程序的可读性和安全性

2.10.7 Collections

专门用来操作集合的工具类
构造方法私有，禁止创建对象
提供一系列静态方法实现对各种集合的操作
具体操作：搜索、复制、排序、线程安全化等

常用方法
addAll()
binarySearch()
copy()
fill(()
max()
min()
reverse()
synchronizedList()

2.10.8 旧的集合类

Vector
实现原理和ArrayList相同，功能相同，都是长度可变的数组结构，很多情况下可以互用

两者的主要区别
Vector是早期JDK接口，ArrayList是替代Vector的新接口
Vector线程安全，效率低下；ArrayList速度快，线程不安全
长度需增长时，Vector默认增长一倍，ArrayList增长50%

Hashable类
实现原理和HashMap相同，功能相同，底层都是哈希表结构，查询速度快，很多情况下可互用
两者的主要区别
Hashtable是早期JDK提供的接口，HashMap是新版JDK提供的接口
Hashtable继承Dictionary类，HashMap实现Map接口
Hashtable线程安全，HashMap线程不安全
Hashtable不允许null值，HashMap允许null值

2.10.9 新的线程同步集合类

早期集合类Vector、Hashtable：线程安全
是怎么保证线程安全的，使用synchronized修饰方法

为了提高性能，使用ArrayList、HashMap替换，线程不安全，但是性能好。

使用ArrayList、HashMap，需要线程安全
使用Collections.synchronizedList(list);Collections.synchronizedMap(map);解决
底层使用synchronized代码锁
虽然是锁住了所有的代码

在大量并发情况下如何提高集合的效率和安全
提供了新的线程同步集合类，位于java.util.concurrent包下，使用lock锁
ConcurrentHashMap
CopyOnWriteArrayList
CopyOnWriteArraySet

2.10.10 集合总结

集合和数组比较
数组不是面向对象的，存在明显的缺陷，集合完全弥补了数组的一些缺点，比数组更灵活更使用，可大大提高软件的开发效率而且不同的集合框架类可适用于不同场合

1.数组容量固定且无法动态改变，集合容量动态改变
2.数组能存放基本数据类型和引用数据类型的数据，而集合类中只能存放引用数据类型的数据
3.数组无法判断其中市级存有多少元素，length只告诉了array容量；集合可以判断实际存有多少元素，而对总的容量不关心
4.集合有多种数据结构（顺序表、链表、哈希表、数等）、多种特征（是否有序、是否唯一）、不同适用场合（查询快，便于删除、排序），不想数组仅采用顺序表方式
5.集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性调用集合实现各种复杂操作，打打提高软件的开发效率

ArrayList和LinkList的联系和区别

Vector和ArrayList的联系和区别

HashMap和Hashtable的联系和区别

Collection和Collections的区别
Collection是Java提供的接口集合，存储一组不唯一，无序的对象。它有两个子接口List和Set

Java中还有一个Collections类，专门用来操作集合类，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

2.11 javaio流

流：流动、流向，从一端移动到另一端。
流是一个抽象、动态的概念，是一连串动态的数据集合。

数据源
data source。提供原始数据的原始媒介，常见的：数据库、文件、其他程序、内存、网络连接、IO设备

在Java程序中，对于数据的输入/输出操作以“流”方式进行
J2SDK提供了各种各样的"流"类，用以获取不同种类的数据；
程序中通过标砖的方法输入或输出输出数据

java的流类型一般位于java.io包中最重要的就是5个类和3个接口

类
File 文件类
InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输入流
Writer 字符输出流

接口
Closeable 关闭流接口
Flushable 刷新流接口
Serializable 序列化接口

2.11.1流分类

输入流：数据源到程序（InputStream、Reader读进来）
输出流：程序到的目的地（OutputStream、Writer写出去）

节点流：可以直接从数据源或目的地读写数据

处理流（包装流）：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能

节点流和处理流的关系：
1.节点流处于IO操作的第一线，所有操作必须通过他们进行；
2.处理流可以对其他流进行处理（提高效率或操作灵活性）

字节流：按照字节读取数据（InputStream、OutputStream）

字符流：按照字符读取数据（Reader、Writer），因为文件编码不同，从而有了对字符进行高效操作的字符流对象。
原理：底层还是基于字节流操作，自动搜寻了指定的码表

2.11.2File

API	说明
pathSeparator separator	路径 路径分隔符
File(String parent,String child) File(File parent,String child) File(String name)	构造器，没有盘符以user.dir作为相对目录
getName() getPath() getAbsolutiePath() getParent()	文件名、路径名
exists() isFile() isDirectory()	判断状态
length()	文件长度
createNewFile() delete()	创建新文件 删除文件
mkdir() mkdirs()	创建目录，如果父目录链不存在一同创建
list()	下级名称
listFiles()	下级File
listRoots()	根路径

2.11.3文件编码

字符集：
java字符使用16位的双字节存储，但是在实际文件存储的数据有各种字符集，需要正确操作，否则就有乱码的发生

字符集	说明
US-ASCII	即英文的ASCII
ISO-8859-1	Latin-1 拉丁字符，包含中文、日文等
UTF-8	变长unicode字符（1-3个字符），国际通用
UTF-16BE	定长Unicode字符（2个字节），大端Big-endian表示
UTF-16LE	定长unicode字符（2个字节），小端little-endian表示
UTF-16	文件中开头指定大端还是小端表示方式，即BOM（Byte-Order-Mark）：FE FF 表示大端，FF FE 表示小端

getBytes()
getBytes(Charset charset)
getBytes(String charsetName)

2.11.4 IO流读写操作

四个抽象类

抽象类	说明	常用方法
InputStream	字节输入流的父类，数据单位为字节	int read() void close()
OutputStream	字节输出流的父类，数据单位为字节	void write(int) void flush() void close()
Reader	字符输入流的父类，数据单位为字符	int read() void close()
Write	字符输出流的父类，数据单位为字符	void write(String) void flush() void close()

2.11.5 文件字节流

FileInputStream
通过字节方式读取文件，适合读取所有类型的文件（图像、视频等），全字符则用FileReader

FileOutputStream
通过字节的方式写出或追加数据到文件，适合所有类型的文件（图像、视频等），全字符则用FileWriter

2.11.6 文件字符流

FileReader
通过字符的方式读取文件，仅适合字符文件

FileWriter
通过字节的方式写出或追加数据到文件中，仅适合字符文件

2.11.7 字节数组流

ByteArrayInputStream

ByteArrayOutputStream

2.11.8 字节缓冲流

BufferedInputStream

BufferedOutputStream

2.11.9 字符缓冲流

BufferedReader

BufferedWriter

2.11.10 转换流

InputStreamReader

OutputStreamWriter

是字节流与字符流之间的桥梁，能将字节流转换为字符流，并且能为字节流指定字符集，可处理一个个的字符

2.11.11 数据流

DataInputStream

DataOutputStream

2.11.12 对象流

ObjectInputStream

ObjectOutputStream

2.11.13 打印流

PrintStream

2.11.14 随机流

RandomAccessFile

2.11.15 合并流

SequenceInputStream