异常处理机制、部分集合

异常

Java程序运行过程中所发生的异常事件可分为两类

• 错误（Error）：JVM系统内部错误、资源耗尽等严重情况
• 异常（Exception）：其它因编程错误或偶然的外在因素导致的一般性问题

程序执行到异常发生处，JVM会创建一个当前异常类对象，并且通过throw关键字throw new 异常名称() 抛出异常，并且打印异常信息，程序不会继续往下执行

可处理异常 Exception：

学习java的核心面向对象（OOP）之后，在java中很多功能的实现都是通过定义类的方式去完成，包括异常机制，java针对在程序中可能会出现的每一种异常，都是通过类的方式去声明，异常在java中也是对象的存在。可处理异常又分为运行时异常和编译时异常， 在程序执行时，如果出现了异常那么java就会针对该异常创建异常对象。java的异常机制是十分强大的，可以帮助开发人员进行排错，这正是java的优势。
​ Exception和RunTimeException的父类都是Throwable

• 运行时异常：

  一般针对发生概率相对特别小的异常，会定义成运行时异常

  运行时异常会直接或间接的继承RunTimeException

  NullPointerException：空指针异常是程序中经常遇见的一种异常情况,接收过来的引用为空，拿着该引用调用方法。空指针异常的解决方案：对接收过来的引用数据类型做非空校验

  ArrayIndexOutofBoundsException：数组下标越界异常，调用数组元素下标超过数组大小

  ArithmeticException：算术运算异常，比如0作为被除数

• 编译时异常：

  一般针对发生概率相对特别大的异常，会定义成编译时异常

  编译时异常会直接或间接的继承Exception

  编译时异常要求开发人员一定要做处理

  FileNotFoundException：文件未找到异常

不可处理异常 Error：

​ 系统内部异常

异常处理机制：

​ try{
​ 具体需要被检测的代码
} catch (异常类 异常类的引用) {
​ 针对该异常的处理
} finally{
​ 该语句体中的内容是无论如何都会执行的，一般是用于资源回收
​ 回收的资源一般是指会造成对系统资源浪费的对象
}

​ 通过这种方式去处理异常，在捕获到异常后，会创建该异常对象，该异常对象会被catch语句块捕获，具体用异常类来接收该异常对象，然后做相应的处理，程序会继续往下执行（try里面捕获到异常，就不会执行后续的语句，继续往下执行指的是try语句块外面后续的内容）。catch语句块可以有多个，因为可能会有多种异常，当catch里异常类用某一特定异常类比如NullPointerException、FileNotFoundException 来接收而不是直接用最大父类 Exception 的时候，可以针对不同的异常做不同的操作，使用不同的catch语句块内容

​ FileNotFoundException案例：

//FileNotFoundException
import java.io.FileInputStream;

public class ExceptionDemo02 {

    public static void main(String[] args) {

        FileInputStream fileInputStream=null;
        try{
            //编译时异常
             fileInputStream= new FileInputStream("F:\\java_work\\day0611");

             return;
        }
        catch (Exception exception)//多态的体现 用最大Exception父类来接收各种异常
        {
            //打印日志的方法
            System.out.println("捕捉到异常");
            exception.printStackTrace();
        }
        //即使在前面try中调用了return finally也是会被执行的
        //除非强制结束虚拟机的进程 finally的语句才不会被执行
        finally {
            if (fileInputStream !=null) {
                try {
                    System.out.println("程序执行到finally");
                    fileInputStream.close();//成功或者失败，流对象使用系统的资源，需要关闭
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            else System.out.println("文件流对象为空");
        }
        System.out.println("程序成功执行到这");
    }
}

​ 执行结果：

捕捉到异常
文件流对象为空
程序成功执行到这
java.io.FileNotFoundException: F:\java_work\day0611 (系统找不到指定的文件。)
	...

​ 结果分析：
​ 这里给了一个无效的路径名，因此会产生异常，然后catch捕获，做catch语句块中的相应操作，然后执行finally语句块的内容，然后跳出try语句块，继续执行余下部分。

​ 当给出一个正确的文件路径，即不会产生异常时，执行结果：

程序执行到finally

​ 这说明，finally语句块的内容无论如何都是会被执行的。即使在创建流对象后，return语句结束掉本方法，也是先执行finally语句块后才实现return。

​ 但是当强制退出虚拟机结束虚拟机进程的时候finally里的语句块不会被运行，强制退出虚拟机System.exit();

异常处理机制的第二种：

​ throws 关键字把异常向上抛给方法的调用处，只是往调用处，那么最终还是要在调用处处理的。
​ throw 关键字，是出现异常后抛出异常

public void getMethod01(String s) throws NullPointerException
{
    //方法体
}

​

自定义异常：

​ 除了java提供的异常外，有时还需要我们自定义异常。自定义异常的方式，直接声明一个类，根据需要确定想自定义成编译时异常还是运行时异常，如果要定义成编译时异常，让该类去继承Exception类，如果是运行时异常，让该类去继承RunTimeException类，然后需要提供一个构造，通过super把异常信息告诉父类即可。

​ 当自定义异常时，定义为编译时异常，在throw new MyException()的方法体前还需要加上throws MyException

自动装箱和自动拆箱：

​ java中所有的基本数据类型都有对应的封装类（引用数据类型），我们学习的集合是只能存放引用数据类型的容器。

自动装箱：

• 自动把基本数据类型转换成引用数据类型

自动拆箱：

• 自动把引用数据类型转换为基本数据类型

//自动装箱：java自动把基本数据类型转换成引用数据类型
//int  --->  Integer
int i=100;//声明一个基本数据类型
Integer i2=i;
//double  --->  Double
double d=3.14;
Double d2=d;
//float  --->  Float
float f=0.12f;
Float f2=f;
//char  --->  Character
char c='i';
Character c2=c;
//byte  --->  Byte
byte b=10;
Byte b2=b;
//short  --->  Short
short s=10;
Short s2=s;
//long  --->  Long
long l=1000;
Long l2=l;
//boolean  --->  Boolean
boolean bo=true;
Boolean bo2=bo;
//自动拆箱 引用数据类型转为基本数据类型
Integer i3=500;
int i4=i3;

Test02 test02=new Test02();
test02.getFunction(1000);
/*传1000能用Object类对象 接收 是因为，自动装箱原理把int型的1000
转为Integer型，然后Integer是Object的子类，可以用Object进行接收，同时也是一种多态的体现*/
public void getFunction(Object object)
    {
        System.out.println(object);
    }

Integer.parseInt(String s)

将字符串类型的s转换成为整型int

String str1="1000";
String str2="1000";
System.out.println(str1+str2);
System.out.println(Integer.parseInt(str1)+
                   Integer.parseInt(str2));

执行结果：

2000
10001000

Collection

集合：

•  集合是容器，只能存放引用数据类型
  

•  每个集合的实现类底层都封装了一种数据结构
  

•  集合是一个接口，继承于Iterable接口，里面只有抽象方法
  

•  每个集合都可以获取迭代器接口
  

集合的结构：

//创建一个集合对象 接口不能实例化 要么new一个实现类要么用匿名对象{}
        Collection collection=new ArrayList();

        //添加元素 1000基本数据类型 这时候会自动装箱
        collection.add(1000);

        //添加浮点型
        collection.add(3.14);

        //添加引用数据类型
        collection.add(new Object());

        //添加接口的实例 (通过匿名内部类)
        collection.add(new myInterface(){
            @Override
            public void get() {
                //重写方法体
            }
        });
        System.out.println(collection.size());

        //遍历集合中的元素
        Iterator iterator =collection.iterator();
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

    }
}
interface myInterface{
    void get();
}
class Student{
}

JDK API 1.6

Collection

方法摘要
boolean	add(E e) 确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear() 移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o) 比较此 collection 与指定对象是否相等。
int	hashCode() 返回此 collection 的哈希码值。
boolean	isEmpty() 如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator() 返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll(Collection<?> c) (Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c) (Collection<?> c) 仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size() 返回此 collection 中的元素数。
Object[]	toArray() 返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。