一、异常
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接口,映射关系具有一定的顺序。
永远相信美好的事情即将发生!!!