java的異常分爲：運行時異常和編譯時異常(也可以說是非運行時異常)。
throws:
1）並沒有真正的處理異常，只是騙過編譯器。
2）逐層的上拋異常，直到main方法。如果main中仍沒有處理，程序會被異常中斷。
3）throws中斷了本層的代碼。
4）throws運行時異常沒有意義
throw:throw 關鍵字，後跟異常對象，直接將異常對象拋出。
自定義異常：只能用throw拋出。分兩步：
1）繼承自Exception或者Exception的子類。
2）提供String做參數的構造，利用父類的String做參數的構造完成初始化，String內容用於對異常的描述。
下面代碼是描述自定義異常的：
ReportNotFoundException.java爲自定義的一種異常類繼承了Exception
package day08;
public class ReportNotFoundException extends Exception{
public ReportNotFoundException(){
}
public ReportNotFoundException(String msg){
super(msg);
}
}接下來是帶有異常處理的代碼：是對以上的測試：
package day08;
public class Employee {
private String name;
public Employee(){
}
public Employee(String name){
this.name = name;
}
public String getReport() throws ReportNotFoundException{
if(Math.random()>0.7){
throw new ReportNotFoundException(name+"找不到報表！");
}
return name+"找到報表了！";
}
}
class Manager {
private Employee[] em;
public Manager(){
}
public Manager(Employee[] em){
this.em = em;
}
public String getReport() throws ReportNotFoundException{
StringBuffer sb = new StringBuffer();
for(int i = 0;i < em.length; i++){
sb.append(em[i].getReport());
}return sb.toString();
}
}
class CFO {
private Manager[] ma;
public CFO(){
}
public CFO(Manager[] ma){
this.ma = ma;
}
public String getReport(){
try{
return ma[0].getReport();
}catch(ReportNotFoundException re){
re.printStackTrace();
}
return null;
}
}
class CEO {
private CFO cfo;
public CEO(CFO cfo){
this.cfo = cfo;
}
public String getReport(){
return cfo.getReport();
}
}接下來是對以上進行的測試：
package day08;
public class Test {
public static void main(String[] args) {
Employee j = new Employee("maidou");
Employee k = new Employee("doudou");
Employee l = new Employee("guaiguai");
Employee[] e = new Employee[]{j,k,l};
Manager[] m = new Manager[]{new Manager(e)};
CFO cfo = new CFO(m);
CEO ceo = new CEO(cfo);
ceo.getReport();
}
}對於編譯時一場來說：一般都是用try-catch-finally來處理掉。方法中可以不處理，用throws上拋，最終會拋給main函數，那麼main函數最終也要上拋，最終會拋給虛擬機，讓虛擬機進行自行處理，顯然這樣是不好的，所以main函數一定要處理掉異常了。
對於運行時異常：可以用try-catch-finally處理，但是對效率和代碼閱讀都有影響，所有一般都是用if條件來使程序健壯。
try-catch-finally結構如下：
try{//只出現一次且爲可能出現異常的代碼
}catch(異常對象){//可出現多次，當多次的時候小的寫上面，大的寫下面，異常時從上到下逐步的捕獲的；捕獲到的對應的異常對象之後所做的處理
}finally{出現0-1次，沒有catch是finally一定要有，而且是一定會執行的代碼
}
通過List、set等接口有多個實現類：
ArrayList：效率高、不直接支持併發，多用於查詢
Vector：效率低、線程安全，直接支持兵法操作，多用於查詢
以上兩個實現類類似於StringBuilder和StringBuffer
HashSet：存儲效率高、查詢效率低，可去重
TreeSet：存儲效率低、查詢效率高，而且會自動調用Compare方法進行自動排序
HashMap、HashTable、TreeMap等等就以後再說吧！
大部分實現類都有增刪改查的方法，下面看一個關於自定義泛型的小例子吧：
實體類Student.java
package day08;
public class Student implements Comparable<Student>{
private int id;
private String name;
public Student() {
super();
}
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
@Override
public int hashCode() {
System.out.println(this.name+":hashCode");
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println(this.name+":equals");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Student o) {
return this.name.compareTo(o.name);
}
}對輸入的信息通過比較字符串排序，其底層而是通過比較字符的ascII碼值來進行的排序
下面是測試類TestStudent.java
package day08;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class TestStudent {
public static void main(String[] args) {
Set<Student> set = new HashSet<Student>();//HashSet判斷元素是否存在，靠hashCode和equals。
Student stu1 = new Student(1,"guaiguai");//而且Set中不可以重複
Student stu2 = new Student(2,"maidou");
Student stu3 = new Student(3,"xiaodoudou");
Student stu4 = new Student(2,"maidou");
set.add(stu1);
set.add(stu2);
set.add(stu3);
set.add(stu4);
System.out.println(set);
System.out.println(set.size());
System.out.println("---------------------------------------");
List<Student> list = new ArrayList<Student>();//ArrayList判斷元素是否存在，或者刪除元素，都是靠equals。
Student stu11 = new Student(1,"guaiguai");//ArryaList中可以重複存在
Student stu21 = new Student(2,"maidou");
Student stu31 = new Student(3,"xiaodoudou");
Student stu41 = new Student(2,"maidou");
list.add(stu11);
list.add(stu21);
list.add(stu31);
list.add(stu41);
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}好啦就先到這裏吧，明天見啦！