2019-12-11-Java常用知识点整理
类的定义和声明
定义：基于面向对象思想，显示生活中具有共同特性对象的抽象就称之为类。
声明：在Java中，通过关键字class来声明类，类声明语法如下：
public class 类名
{
//定义类属性
属性A的类型 属性A;
属性B的类型 属性B;
……
属性N的类型 属性N;
//方法
方法a：
……
方法n：
}
类的实例化
创建对象的几种方式（）
简言之，即是:new/反射/clone()/反序列化
a.使用new关键字 } → 调用了构造函数
b.使用Class类的newInstance方法 } → 调用了构造函数
c.使用Constructor类的newInstance方法 } → 调用了构造函数
d.使用clone方法 } → 没有调用构造函数
e.使用反序列化 } → 没有调用构造函数
a、使用new关键字
这是最常见也是最简单的创建对象的方式了。通过这种方式，我们可以调用任意的构造函数(无参的和带参数的)。
Employee emp1 = new Employee();
b、使用Class类的newInstance方法
这个newInstance方法调用无参的构造函数创建对象。
Employee emp2 = (Employee) Class.forName("com.example.Employee").newInstance();
或者
Employee emp2 = Employee.class.newInstance();
c、使用Constructor类的newInstance方法
和Class类的newInstance方法很像， java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。
Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();
事实上Class的newInstance方法内部调用Constructor的newInstance方法。
d、使用clone方法
无论何时我们调用一个对象的clone方法，jvm就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。要使用clone方法，需要先实现Cloneable接口并实现其定义的clone方法。
Employee emp4 = (Employee) emp3.clone();
e、使用反序列化
当我们序列化和反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现Serializable接口。
ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();
接口的定义和声明
接口的概念：
在Java中接口是一个全部由抽象方法组成的集合，接口需要用interface定义，里面只能有抽象的方法和常量。
定义一个接口：
interface Inter {
public static final int i=10; //全局常量前缀public static final
public abstract void eat(); //抽象的方法
}
接口的声明：
Public interface 接口名 extends 接口列表
补充：接口
a、没有变量的声明，可定义常量 //[public][static]（或[final]）常量； b、只有方法的声明，没有方法的实现//[public][abstract]方法
`
接口的实现
接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements
[修饰符] class<类名>[extends 父类名][implents 接口列表]{}
常用类和数据结构-String类
以下来自Jdk1.8api
String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享。 例如：
String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
以下是一些如何使用字符串的示例：
System.out.println("abc");
String cde = "cde";
System.out.println("abc" + cde);
String c = "abc".substring(2,3);
String d = cde.substring(1, 2);
String类包括用于检查序列的各个字符的方法，用于比较字符串，搜索字符串，提取子字符串以及创建将所有字符翻译为大写或小写的字符串的副本。 案例映射基于Character类指定的Unicode标准版本。
Java语言为字符串连接运算符（+）提供特殊支持，并为其他对象转换为字符串。 字符串连接是通过StringBuilder （或StringBuffer ）类及其append方法实现的。 字符串转换是通过方法来实现toString ，由下式定义Object和继承由在Java中的所有类。 有关字符串连接和转换的其他信息，请参阅Gosling，Joy和Steele， Java语言规范 。
String常用方法
常用length、isEmpty、equals、indexOf、charAt、subString、getChars、startsWith、endWith等方法。
public String substring(int beginIndex,int endIndex)返回一个字符串，该字符串是此字符串的子字符串。 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。 因此，子串的长度为endIndex-beginIndex 。
public int indexOf(String str,
int fromIndex)返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。 public char charAt(int index)返回char指定索引处的值。 指数范围为0至length() - 1 。 该序列的第一个char值在索引0 ，下一个索引为1 ，依此类推，与数组索引一样。
public void getChars(int srcBegin,
int srcEnd,
char[] dst,
int dstBegin)将此字符串中的字符复制到目标字符数组中。
public int compareTo(String anotherString)按字典顺序比较两个字符串。 比较是基于字符串中每个字符的Unicode值。
public boolean startsWith(String prefix)测试此字符串是否以指定的前缀开头。
参数
prefix - 前缀。
结果
true如果由参数表示的字符序列是由该字符串表示的字符序列的前缀; false否则。 还需要注意的是true如果参数为空字符串或等于该将被返回String如由所确定的对象equals(Object)方法。
endsWith类似
public int hashCode()返回此字符串的哈希码。 String对象的哈希代码计算为
s[0]31^(n-1) + s[1]31^(n-2) + ... + s[n-1]
String、StringBuffer和StringBuilder使用比较
String见上一条目
StringBuffer：可变字符串序列，线程安全
StringBuilder：可变字符串序列，线程不安全，高效
StringBuffer构造方法
StringBuffer() ：
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。（容量是可以自动扩容的）
自己理解 ：创建一个空的字符序列（频繁的扩容很耗时）。
StringBuffer(int capacity)
构造一个不带字符，但具有指定初始容量的字符串缓冲区。
自己理解 ：创建了一个空的字符序列，容量为capacity。
StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
自己理解 ：创建了容量为 str.length+16容量的字符串序列，里面存储了字符串str。
append()方法：（重写）
StringBuffer append(Object obj)
追加 Object 参数的字符串表示形式。
注：调用的是toString（）方法，拼接的是toString方法返回的字符串。
StringBuffer append(char[] str)
将 char 数组参数的字符串表示形式追加到此序列。
注：是将数组里的内容进行拼接，而不是调用toString（）
StringBuffer append(boolean b)
将 boolean 参数的字符串表示形式追加到序列。
StringBuffer append(char c)
将 char 参数的字符串表示形式追加到此序列。
StringBuffer append(char[] str, int offset, int len)
将 char 数组参数的子数组的字符串表示形式追加到此序列。
StringBuffer append(CharSequence s)
将指定的 CharSequence 追加到该序列。
StringBuffer append(CharSequence s, int start, int end)
将指定 CharSequence 的子序列追加到此序列。
StringBuffer append(double d)
将 double 参数的字符串表示形式追加到此序列。
StringBuffer append(float f)
将 float 参数的字符串表示形式追加到此序列。
StringBuffer append(int i)
将 int 参数的字符串表示形式追加到此序列。
StringBuffer append(long lng)
将 long 参数的字符串表示形式追加到此序列。
StringBuffer append(String str)
将指定的字符串追加到此字符序列。
StringBuffer append(StringBuffer sb)
将指定的 StringBuffer 追加到此序列中。
insert（）方法：（重写）
StringBuffer insert(int offset, boolean b)
将 boolean 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, char c)
将 char 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, char[] str)
将 char 数组参数的字符串表示形式插入此序列中。
StringBuffer insert(int index, char[] str, int offset, int len)
将数组参数 str 的子数组的字符串表示形式插入此序列中。
StringBuffer insert(int dstOffset, CharSequence s)
将指定 CharSequence 插入此序列中。
StringBuffer insert(int dstOffset, CharSequence s, int start, int end)
将指定 CharSequence 的子序列插入此序列中。
StringBuffer insert(int offset, double d)
将 double 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, float f)
将 float 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, long l)
将 long 参数的字符串表示形式插入此序列中。
StringBuffer insert(int offset, Object obj)
将 Object 参数的字符串表示形式插入此字符序列中。
StringBuffer insert(int offset, String str)
将字符串插入此字符序列中。 `
StringBuffer删除方法
` delete(int start, int end)
移除此序列的子字符串中的字符。
移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。
参数：（包左不包右）
start - 起始索引（包含）。
end - 结束索引（不包含）。
StringBuffer deleteCharAStringBuffert(int index)
移除此序列指定位置的 char。
移除此序列指定位置的 char。此序列将缩短一个 char。
注：如果给定索引处的字符是增补字符，则此方法将不会移除整个字符。如果需要准确处理增补字符，那么可以通过调用 。
StringBuffer替换方法
StringBuffer replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。先将子字符串中的字符移除，然后将指定的 String 插入 start。（如果需要，序列将延长以适应指定的字符串。）
参数：（包左不包右）
start - 起始索引（包含）。
end - 结束索引（不包含）。
str - 将替换原有内容的字符串。
StringBuffer反转功能
StringBuffer reverse()
概述:将此字符序列用其反转形式取代。
截取功能
String substring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列。该子字符串始于指定索引处的字符，一直到此字符串末尾。
参数：
start - 起始索引（包含）。
返回：(注意：上面个所写的方法修改的都是本身，而subString返回的是一个String类型的字符串)
新的字符串。
String substring(int start, int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。
返回一个新的 String，它包含此序列当前所包含的字符子序列。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符。
参数（包左不包右）：
start - 起始索引（包含）。
end - 结束索引（不包含）。
返回：
新的字符串。
常用类和数据结构-包装类
8 种 基本数据类型及对应的 8 种包装数据类型。
包装类型是为了解决基本数据类型无法面向对象编程所提供的。
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| boolean | Boolean |
| short | Short |
| char | Char |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
包装类的数值转换
常用类和数据结构-容器类
Collection
Set 不能重复
HashSet、Vector
List
ArrayList、linkedlist
Map
HashMap
HashTable 线程安全
IO流
字节流
（1）字节流基类
1）InputStream
InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类。
常用方法：
// 从输入流中读取数据的下一个字节
abstract int read()
// 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int read(byte[] b)
// 将输入流中最多 len 个数据字节读入 byte 数组
int read(byte[] b, int off, int len)
// 跳过和丢弃此输入流中数据的 n个字节
long skip(long n)
// 关闭此输入流并释放与该流关联的所有系统资源
void close()
2）OutputStream
OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。
常用方法：
// 将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输出流
abstract void write(int b)
// 关闭此输出流并释放与此流有关的所有系统资源
void close()
// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()
（2）字节文件操作流
1）FileInputStream
FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。
构造方法：
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
FileInputStream(File file)
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定
FileInputStream(String name)
常用方法：覆盖和重写了父类的的常用方法。
// 读取f盘下该文件f://hell/test.txt
//构造方法1
InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
int i = 0;
//一次读取一个字节
while ((i = inputStream.read()) != -1) {
// System.out.print(i + " ");// 65 66 67 68
//为什么会输出65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。
System.out.print((char) i + " ");// A B C D
}
//关闭IO流
inputStream.close();
// 读取f盘下该文件f://hell/test.txt
//构造方法2
InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
// 字节数组
byte[] b = new byte[2];
int i2 = 0;
// 一次读取一个字节数组
while ((i2 = inputStream2.read(b)) != -1) {
System.out.print(new String(b, 0, i2) + " ");// AB CD
}
//关闭IO流
inputStream2.close();
注： 一次读取一个字节数组，提高了操作效率,IO流使用完毕一定要关闭。
2）FileOutputStream
FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。
构造方法：
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)
常用方法：覆盖和重写了父类的的常用方法。
OutputStream outputStream = new FileOutputStream(new File("test.txt"));
// 写出数据
outputStream.write("ABCD".getBytes());
// 关闭IO流
outputStream.close();
// 内容追加写入
OutputStream outputStream2 = new FileOutputStream("test.txt", true);
// 输出换行符
outputStream2.write("\r\n".getBytes());
// 输出追加内容
outputStream2.write("hello".getBytes());
// 关闭IO流
outputStream2.close();
注；输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。
（3）字节缓冲流（高效流）
1）.BufferedInputStream
BufferedInputStream：字节缓冲输入流，提高了读取效率。
构造方法：
// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
InputStream in = new FileInputStream("test.txt");
// 字节缓存流
BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {
System.out.print(new String(bs, 0, len));
// ABCD
// hello
}
// 关闭流
bis.close();
2）BufferedOutputStream
BufferedOutputStream：字节缓冲输出流，提高了写出效率。
构造方法：
// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)
常用方法：
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输出流
void write(int b)
// 刷新此缓冲的输出流
void flush()
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
// 输出换行符
bos.write("\r\n".getBytes());
// 输出内容
bos.write("Hello Android".getBytes());
// 刷新此缓冲的输出流
bos.flush();
// 关闭流
bos.close();
字符流
（1）字符流基类
1）Reader
Reader:读取字符流的抽象类.
常用方法：
// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 跳过字符
long skip(long n)
// 关闭该流并释放与之关联的所有资源
abstract void close()
2）Writer
Writer:写入字符流的抽象类.
常用方法：
// 写入字符数组
void write(char[] cbuf)
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
// 写入单个字符
void write(int c)
// 写入字符串
void write(String str)
// 写入字符串的某一部分
void write(String str, int off, int len)
// 将指定字符添加到此 writer
Writer append(char c)
// 将指定字符序列添加到此 writer
Writer append(CharSequence csq)
// 将指定字符序列的子序列添加到此 writer.Appendable
Writer append(CharSequence csq, int start, int end)
// 关闭此流，但要先刷新它
abstract void close()
// 刷新该流的缓冲
abstract void flush()
（2）字符转换流
1）InputStreamReader
InputStreamReader：字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
构造方法：
// 创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
// 创建使用给定字符集的 InputStreamReader
InputStreamReader(InputStream in, Charset cs)
// 创建使用给定字符集解码器的 InputStreamReader
InputStreamReader(InputStream in, CharsetDecoder dec)
// 创建使用指定字符集的 InputStreamReader
InputStreamReader(InputStream in, String charsetName)
特有方法：
//返回此流使用的字符编码的名称
String getEncoding()
//使用默认编码
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"));
int len;
while ((len = reader.read()) != -1) {
System.out.print((char) len);//爱生活，爱Android
}
reader.close();
//指定编码
InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8");
int len;
while ((len = reader.read()) != -1) {
System.out.print((char) len);//????????Android
}
reader.close();
注：Eclipse默认使用GBK编码,test.txt文件所以是GBK编码，当指定utf-8编码时所以会乱码。
2）OutputStreamWriter
OutputStreamWriter：字节流转字符流。
构造方法：
// 创建使用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out)
// 创建使用给定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs)
// 创建使用给定字符集编码器的 OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
// 创建使用指定字符集的 OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)
特有方法：
//返回此流使用的字符编码的名称
String getEncoding()
（3）字符缓冲流（高效流）
1）.BufferedReader
BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
构造方法：
// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
特有方法：
// 读取一个文本行
String readLine()
//生成字符缓冲流对象
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
String str;
//一次性读取一行
while ((str = reader.readLine()) != null) {
System.out.println(str);// 爱生活，爱Android
}
//关闭流
reader.close();
2）BufferedWriter
BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
构造方法：
// 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out)
// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
BufferedWriter(Writer out, int sz)
特有方法：
// 写入一个行分隔符
void newLine()
（4）FileReader、FileWriter
FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。
高效流效率对比
以下为实操记录
//读取方式一
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
int len;
// 开始时间
long begin = System.currentTimeMillis();
// 一次读取一个字节
while ((len = inputStream.read()) != -1) {
outputStream.write(len);
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 耗时213195ms
//关闭流释放资源
inputStream.close();
outputStream.close();
//读取方式二
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
int len;
byte[] bs = new byte[1024];
// 开始时间
long begin = System.currentTimeMillis();
// 一次读取一个字节数组
while ((len = inputStream.read(bs)) != -1) {
outputStream.write(bs, 0, len);
}
System.out.println(System.currentTimeMillis() - begin);// 用时281毫秒
inputStream.close();
outputStream.close();
//读取方式三：
FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
BufferedInputStream bis = new BufferedInputStream(inputStream);
FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
BufferedOutputStream bos = new BufferedOutputStream(outputStream);
int len;
byte[] bs = new byte[1024];
// 开始时间
long begin = System.currentTimeMillis();
while ((len = bis.read(bs)) != -1) {
bos.write(bs, 0, len);
// bos.flush();
}
// 用时毫秒
System.out.println(System.currentTimeMillis() - begin);// 耗时78ms
bis.close();
bos.close();
Java的异常
Throwable：有两个重要的子类：Exception（异常）和Error（错误），两者都包含了大量的异常处理类。
Error（错误）
是程序中无法处理的错误，表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题。
通常有
Virtual MachineError（虚拟机运行错误）、
NoClassDefFoundError（类定义错误）等。
比如说当jvm耗完可用内存时，将出现OutOfMemoryError。此类错误发生时，JVM将终止线程。
这些错误是不可查的，非代码性错误。因此，当此类错误发生时，应用不应该去处理此类错误。
Exception（异常）
程序本身可以捕获并且可以处理的异常。
Exception这种异常又分为两类：运行时异常和编译异常
1、运行时异常(不受检异常)：RuntimeException类极其子类表示JVM在运行期间可能出现的错误。比如说试图使用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。
2、编译异常(受检异常)：Exception中除RuntimeException极其子类之外的异常。如果程序中出现此类异常，比如说IOException，必须对该异常进行处理，否则编译不通过。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。
可查异常与不可查异常：java的所有异常可以分为可查异常（checked exception）和不可查异常（unchecked exception）。
1、可查异常：编译器要求必须处理的异常。正确的程序在运行过程中，经常容易出现的、符合预期的异常情况。一旦发生此类异常，就必须采用某种方式进行处理。除RuntimeException及其子类外，其他的Exception异常都属于可查异常。编译器会检查此类异常，也就是说当编译器检查到应用中的某处可能会此类异常时，将会提示你处理本异常——要么使用try-catch捕获，要么使用throws语句抛出，否则编译不通过。
2、不可查异常：编译器不会进行检查并且不要求必须处理的异常，也就说当程序中出现此类异常时，即使我们没有try-catch捕获它，也没有使用throws抛出该异常，编译也会正常通过。该类异常包括运行时异常（RuntimeException极其子类）和错误（Error）。
对于不同的异常，java采用不同的异常处理方式。
1、运行异常将由系统自动抛出，应用本身可以选择处理或者忽略该异常。
2、对于方法中产生的Error，该异常一旦发生JVM将自行处理该异常，因此java允许应用不抛出此类异常。
3、对于所有的可查异常，必须进行捕获或者抛出该方法之外交给上层处理。也就是当一个方法存在异常时，要么使用try-catch捕获，要么使用该方法使用throws将该异常抛调用该方法的上层调用者。
浙公网安备 33010602011771号