自学Java Part 5

一、异常

1、Java异常

定义：
在程序运行过程中发生的异常世界。
分类：

Exception为所有异常类的父类，其子类对应各种各样的异常事件。
RuntimeException类的常用子类有数组下标越界异常(ArrayIndexOutOfBoundsException) 、空指针异常(NullPointerException) 、算术异常(ArithmeticException) 、数字格式异常(NumberFomatException)。
而IOException输入/输出异常(I/OException) 、操作数据库异常(SQLException) 、文件未找到异常（ClassNotFoundException）、非法访问权限（IllegalAccessException）。
Error类及其子类对象由Java虚拟机生成并抛出，为系统级错误。
默认处理机制：
代码运行错误，Java虚拟机会自动抛出异常到控制台上，并终止应用程序。

2、异常处理

（1）try-catch方式处理异常
格式：
try {
异常的代码;
} catch(异常类名 变量名) {
异常的处理代码;
}
try{…}将可能发生异常语句放在try中。
catch是对异常对象进行处理的代码。

public class Phone{
	public static void main(String[] args) {

	String phone[] = { "huawei", "xiaomi", "oppo","vivo" };
	try {
		for (int i = 0; i < 6; i++) {
			System.out.println(phone[i]);
		}
	} catch (java.lang.ArrayIndexOutOfBoundsException e) {
		System.out.println("数组访问越界");
	} finally {
		System.out.println("程序终止");
	}
}
}

当访问phone[4],ArrayIndexOutOfBoundsException数组越界异常，catch子句捕捉到异常后，finally子句输出程序终止。
一段代码会引发多个异常，用catch子句罗列的形式捕捉异常，不同的异常要用多个catch罗列，罗列原则：
try块中先发生异常的代码对应的catch子句先罗列。
catch子句中为具体异常对象的先罗列。
catch子句中为Exception类型异常的后罗列。
（2）Throwable类
1、public String getMessage()
System.out.println(e.getMessage());
返回此 throwable 的详细消息字符串
2、public String toString()
System.out.println(e.toString());
返回此可抛出的简短描述
3、public void printStackTrace()
e.printStackTrace();
把异常的错误信息输出在控制台
（3）throws方式
public void 方法() throws Exception
{
}
Exception是所有异常，也可以是异常列表，异常列表中所有异常对象之间以“，”隔开。这个throws格式是跟在方法的括号后面的。
（4）throw
格式：
throw ThrowableInstance;
ThrowableInstance是Throwable类类型或者Throwable子类类型的对象。
throw用在方法体内，跟的是异常对象名
表示抛出异常，由方法体内的语句处理

3、自定义异常

先生成异常对象，然后通过throw实现抛出，如
IOException e = new IOException();
throw e;
抛出的异常是Throwable子类。
检查性异常类， 继承Exception类。
运行时异常类， 继承RuntimeException类。
如：
自定义异常类

public class ScoreException extends Exception {
public ScoreException() {}
public ScoreException(String message) {
super(message);
}
}

定义分数类

public class Score {
public void checkScore(int score) throws ScoreException {
if(score<0 || score>750) {
throw new ScoreException("成绩错误");
} else {
System.out.println("成绩正常");
}
}
}

定义测试类

import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入高考分数：");
int score = sc.nextInt();
Score t = new Score();
try {
t.checkScore(score);
} catch (ScoreException e) {
e.printStackTrace();
}
}
}

如输入：999

输入高考分数：
999
ScoreException: 成绩错误
	at Score.checkScore(Score.java:4)
	at Test.main(Test.java:9)

二、集合类

1、集合

（1）定义：
是一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
特点：
只容纳对象名，所有元素是object类型，大小可变。
（2）结构：
第一棵树根节点为collection

定义集合的基本操作，添加、删除、遍历。
第二棵树根节点为Map接口

与散列表类似，保存的是键值对的集合，可以通过键来实现对值元素的访问。
（3）collection接口
创建Collection集合的对象：
Collection < string > c= new 类名 < string > （）；
常用方法：
add(Object e) -------添加元素
remove(Object o) ------从集合中移除指定的元素
void clear()------- 清空集合中的元素
contains(Object o) ---------判断集合中是否存在元素
isEmpty() --------判断集合是否为空
size() ---------集合中元素的个数
(4)迭代器
是集合的专用遍历方式

import java.util.ArrayList;
import java.util.*;
public class Bianli {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add("a");
		c.add("b");
		c.add("d");
		c.add("c");
		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
		String s = it.next();
		System.out.println(s);
		}
		}
}

2、List集合

（1）List接口
List接口继承了Collection接口
get(int index)
得到指定索引位置元素
set(int index,Object obj)
将指定索引元素修改为指定的对象
（2）ArrayList类
实现可变的数组，可以保存所有元素，可以根据索引对集合进行访问。
实现List集合
List < String > list1=new ArrayList< String >();
如将指定索引为999移除

import java.util.ArrayList;
import java.util.*;
public class Bianli {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add("1");
		c.add("2");
		c.add("3");
		c.add("999");
		c.remove("999");
		Iterator<String> it = c.iterator();
		while (it.hasNext()) {
		String s = it.next();
		System.out.println(s);
		}
		}
}

（3）LinkedList类
采用链表结构保存对象，向集合快速插入删除对象。
List < String > list1=new LinkedList< String >();

（4）列表迭代器
ListIterator

import java.util.ArrayList;
import java.util.*;
public class Bianli {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("996");
		list.add("989");
		list.add("972");
		ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
		String s = lit.next();
		}
		System.out.println(list);
		}
}

[996, 989, 972]

3、Set集合

其中对象不按特定的方式排序，对象不能重复。
哈希值,是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。
Object类中的public int hashCode()：返回对象的哈希码值。
（1）HeshSet
特点：
底层数据结构是哈希表
对集合的迭代顺序不一定，存储和取出的元素顺序不一定
没有带索引的方法，不能使用普通for循环遍历
由于是Set集合，是不包含重复元素的集合
如

import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;
public class Bianli {
		public static void main(String[] args) {
				HashSet<String> hs = new HashSet<String>();
				hs.add("996");
				hs.add("989");
				hs.add("972");
				Iterator<String> it = hs.iterator();
				while (it.hasNext()) {
				String s = it.next();
				System.out.println(s);
}
}
}

输出

972
996
989

（2）TreeSet
特点：
元素有序，按一定的规则进行排序，具体排序方式取决于构造方法
根据其元素的自然排序进行排序
不能使用普通for循环遍历
不包含重复元素的集合

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
public class Bianli {
		public static void main(String[] args) {
			TreeSet a= new TreeSet();
				a.add(996);
				a.add(989);
				a.add(972);
				Iterator it = a.iterator();
				while (it.hasNext()) {
				System.out.println(it.next());
}
}
}

结果

972
989
996

4、Map集合

（1）Map接口
提供将键映射到值的对象
方法：
put(K a，V b) 向集合中的a与b的映射关系
get(Object a) 存在指定的a， 返回该对象对应的值， 否则返回null
containsKey(Object value) 判断集合是否包含指定的键
containsValue() 判断集合是否包含指定的值
keySet() 获取集合中所有键的集集合
valuse() 获取集合中所有值的集合
(2)实现类
HaspMap类基于Map接口的实现，可以使用null值和null键，要保证键的唯一性。
TreeMap类不仅实现Map接口，还实现java.util.SortedMap接口，映射关系具有一定的顺序。

永远相信美好的事情即将发生！！！