第八周课程总结&实验报告（六）

第八周课程总结

一、异常类的继承结构

在Java的异常结构中，有两个最常用的类：Exception、Error，这两个类全是Thorwable的子类。

Exception：一般表示的是程序中出现的问题，可以使用try...catch语句处理。

Error：一般指的是JVM错误，程序中无法处理。

一般情况下，开发者都比较习惯于把上面的两者统称为异常。而之前的算术异常、数字格式化异常等都属于Exception的子类。

二、Java的异常处理机制

在整个Java的异常处理中，实际上也是按照面向对象的方式进行处理。处理的步骤如下：

（1）一旦产生异常，则首先会产生一个异常类的实例化对象；

（2）在try语句中对此异常对象进行捕捉；

（3）产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功，则执行catch语句中的代码。如下图：

三、使用Exception处理其他的异常

根据对象的多态性，所有的子类实例可以全部使用父类接收，那么就可以利用向上转型的概念，让所有的异常对象都使用Exception接收。

但是，在Java中所有捕获范围小的异常必须放在捕获大的异常之前，否则程序在编译的时候就会出现错误提示。

另外，对于一个程序，如果有多个异常最好分别进行捕获，而不是直接使用Exception捕获全部异常。

四、throws与throw关键字

throws概念：在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理。

throws使用格式：

public 返回值类型 方法名称(参数列表...)throws 异常类{}

throw关键字概念：可以直接使用throw关键字抛出一个异常，抛出时直接抛出异常类的实例化对象即可。

五、Exception类与RuntimeException类

这两个类的区别如下：

（1）Exception在程序中必须使用try...catch进行处理。

（2）RuntimeException可以不使用try...catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。

（3）RuntimeException是Exception的子类。

六、自定义异常类

概念：用户可以根据自己的需要定义自己的异常类。

定义异常类，只需要继承Exception类或者是RuntimeException类即可。

七、代码块

组成：普通代码块、构造块、静态代码块、同步代码块。

八、多线程

进程与线程

进程：进程是程序的一次动态执行过程。它经历了从代码块加载、执行到执行完毕的一个完整的过程。这个过程也是进程本身从产生、发展到最终消亡的过程。

多线程：多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，是在进程的基础上的进一步划分。

九、Java中线程的实现

继承Thread类和实现Runnable接口。

Thread类是在java.lang包中定义的。一个类只要继承了Thread类，此类就称为多线程操作类。在Thread子类中，必须明确的覆写Thread类中的run()方法。此方法为线程的主体。

线程的定义格式如下：

class 类名称 extends Thread{
        属性...;
        方法...;
        public void run(){
                    线程主体;
        }
}

实现Runnable接口

在Runnable接口中只提供有一个抽象方法run()。

使用Runnable接口的格式如下：

class 类名称 implements Runnable{
        属性...;
        方法...;
        public void run(){
                    线程主体;
        }
}

十、启动线程

如果想正确的启动线程，是不能直接调用run()方法的，而是应该调用从Thread类中继承而来的start()方法来实现的。

在线程启动时虽然调用的是start()方法，但实际上调用的是run()方法的主体。

一个类通过继承Thread类来实现，那么只能调用一次start()方法，如果调用多次，则会抛出IllegalThreadStateException的异常。

在继承Thread类中启动线程是通过start()方法来实现的。而在Runnable接口中也是依靠Thread类完成启动的，在Thread类中提供了public Thread(Runnable target)和public Thread(Runnable target,String name)两个构造方法来实现的。

从上面的两种实现可以发现，无论使用哪种方式，最终都必须依靠Thread类才能启动多线程。

十一、Thread类与Runnable接口的区别

如果一个类继承Thread类，则不适合于多个线程共享资源，而实现Runnable接口，就可以方便的实现资源共享。

十二、同步与死锁

一个多线程的程序，如果通过Runnable接口实现的，则意味着类中的属性将被多个线程共享，因此，如果这多个线程要操作同一资源时，就有可能出现资源的同步问题。

使用同步解决问题

如果在代码块上加上synchronized关键字则此代码块就称为同步代码块。

同步代码块格式：

synchronized(同步对象){
        需要同步的代码;
}

除了可以将需要的代码设置成同步代码块之外，也可以使用synchronized关键字将一个方法声明成同步方法。

同步方法格式：

synchronized 方法返回值 方法名称(参数列表){
        //方法体
}

死锁

所谓的死锁就是指两个线程都在等彼此先完成，造成了程序的停滞状态。

实验报告（六）

实验内容

编写一个类，在其main()方法中创建一个一维数组，在try字句中访问数组元素，使其产生ArrayIndexOutOfBoundsException异常。在catch子句里捕获此异常对象，并且打印“数组越界”信息，加一个finally子句，打印一条信息以证明这里确实得到了执行。

源代码:

package dibazhou;

public class Sy1 {

    public static void main(String[] args) {
        int a[]=null;
        a=new int[1];
        try {
            for(int i=0;i<=3;i++) {
                a[i]=i;
            }
        }catch(ArrayIndexOutOfBoundsException ai) {
            System.out.println("捕获的异常："+ai);
            System.out.println("数组越界");
        }finally {
            System.out.println("此语句可以执行...");
        }
    }

}

运行截图：

自我评价：这个题目还是很很简单的，按照要求一步一步来就可以了。

车站检查危险品的设备，如果发现危险品会发出警告。编程模拟设备发现危险品。

编写一个Exgeption的子类DangerException，该子类可以创建异常对象，该异常对象调用toShow()方法输出“危险物品”。编写一个Machine类，该类的方法checkBag(Goods goods)当发现参数goods是危险品时（goods的isDanger属性是true）将抛出DangerException异常。

程序在主类的main()方法中的try-catch语句的try部分让Machine类的实例调用checkBag(Goods goods)的方法，如果发现危险品就在try-catch语句的catch部分处理危险品。

DangerException类

package dibazhou;

class DangerException extends Exception{
    private String m;
    public String getM() {
        return m;
    }
    public void setM(String m) {
        this.m = m;
    }
    public DangerException(String m) {
        this.m=m;
    }
    public void toShow() {
        System.err.println("危险物品："+m);
    }
}

Machine类

package dibazhou;

public class Machine {
    private Goods goods;
    public void checkBag(Goods goods)throws DangerException {
        if(goods.isDanger) {
            throw new DangerException(goods.getName());
        }
        else {
            System.out.println(goods.getName()+"不是危险物品！");
        }
    }
    public Goods getGoods() {
        return goods;
    }
    public void setGoods(Goods goods) {
        this.goods = goods;
    }
}

Goods类

package dibazhou;

public class Goods {
    private String name;
    boolean isDanger=true;
    public Goods(String name) {
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public boolean isDanger() {
        return isDanger;
    }
    public void setDanger(boolean isDanger) {
        this.isDanger = isDanger;
    }
}

测试类

package dibazhou;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
         ArrayList list=new ArrayList();
         list.add("汽油");
         list.add("管制刀具");
         list.add("枪支");
         list.add("宠物");
         Goods goods=new Goods("汽油");
         Machine machine=new Machine();
         try {
             machine.checkBag(goods);
         }catch(DangerException d) {
             d.toShow();
         }
    }

}

实验截图：

自我评价：对于这个题目，自己心里存在着许多的疑问，老师讲的时候好像都听懂了，但到了自己来做的时候，就有些不会了，还是自己没怎么学好。