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

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

package test;

public class Research{
    public static void main(String args[]) {
        int a[]= {1,2,3,4};
        try {
            for(int j=0;j<5;j++) {
                System.out.println(a[j]);
            }
        }
        catch(Exception e) {
            e.printStackTrace();
            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部分处理危险品。

 

package resech;

class DangerException extends Exception{
    private String message;
    public DangerException(){
        message="危险物品";
    }
    public DangerException(String m){
        message=m+"危险物品";
    }
    public void toshow() {
        System.out.println(message);
    }
}
public class Goods {
    private String goodsname;
    public boolean isDanger;
    public boolean getIsDanger() {
        return isDanger;
    }
    public void setIsDanger(boolean i) {
        this.isDanger=i;
    }
    public String getgoodsname() {
        return goodsname;
    }
    public void setgoodsname(String g) {
        this.goodsname=g;
    }
}
public class Machine {
    public void checkBag(Goods goods) throws DangerException {
        if(goods.getIsDanger()) {
            throw new DangerException(goods.getgoodsname());
        }
        else {
            System.out.println(goods.getgoodsname()+"不是危险物品");
        }
    }
}
public class end {

    public static void main(String[] args) {
        Goods goods=new Goods();
        Machine m=new Machine();
        String s[]= {"汽油","刀","书包","方便面"};
        for(int j=0;j<s.length;j++) {
            goods.setgoodsname(s[j]);
            if(goods.getgoodsname().equals("汽油")||goods.getgoodsname().equals("刀")) {
                goods.setIsDanger(true);
            }
            else {
                goods.setIsDanger(false);
            }
            try {
                m.checkBag(goods);
            }
            catch(DangerException e) {
                e.toshow();
            }
        }
    }  

}

学习总结：

一，包装类： 

(附：Java的数据类型分为基础数据类型和引用数据类型，基础类型有：int,char,long,short,float,double,boolean,byte,引用数据类型：类、接口类型、数组类型、枚举类型、注解类型。区别：基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。）

1，各基本数据类型的包装类：int——>Integer,char——>Character,short——>Short,long——>Long,float——Float,double——>Double,boolean——>Boolean,byte——>Byte,其中Integer,Byte,Float,Double,Long,Short都属于Number的子类，Number类本身提供了一系列的返回以上6中基本数据类型的操作。Boolean和Character属于Object的直接子类。

Number类的定义：

格式：访问权限 (抽象类+)数据类型 方法名() 

2，装箱与拆箱：

概念：

装箱：将一个基本数据类型变为包装类，拆箱：将一个包装类变为基本数据类型。

例：

public class WrapperDemon01{
       public static void main(String[] args){
             int x=30;//声明一个基本数据类型
             Integer i=new Integer(x);//装箱
             int temp=i.intValue();//拆箱
       }
}

3，将一个全由数字组成的字符串变成一个int或float类型数据

方法：

1),Integer类：

public static int parselnt(String s)throws NumberFormatException

2),Float类

public static float parseFloat(String s)throws NumberFormatException

例：

public class WrapperDemo04{
      public static void main(String[] args){
            String str1="30";
            String str2="30.3";
            int x=Integer parselnt(str1);
            float f=Float parseFloat(str2);
            System.out.println("整数乘方："+x+"*"+x+"="+(x*x));
            System.out.println("小数乘方："+f+"*"+f+"="+(f*f));
      }
}

结果：整数除法：30*30=900

          小数乘法：30.3*30.3=918.08997

二，自定义异常类：

作用：处理Java处理不了的异常

格式：

public  class  自定义异常  extends   Exception{}

自定义异常总包括如下构造函数：

1）一个无参构造函数

2）一个带有String参数的构造函数，并传递给父类的构造函数。

3）一个带有String参数和Throwable参数，并都传递给父类构造函数

4）一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

(出自：https://www.cnblogs.com/lulipro/p/7504267.html)

三，多线程：

1，概念：是实现并发机制的一种有效手段。

2，进程和线程：

进程：是程序的一次动态执行过程。

线程： 是比进程更小的执行单位，是在进程的基础上进行的进一步划分。

3，线程的实现：

1），继承Tread类：

Tread类是java.lang包定义的。一个类只要继承了Tread类，此类就称为多线程操作类。

多线程的定义语法：

class 类名称 extends Tread{
      属性...;
      方法...:
      public void run(){     //Tread子类中必须覆写Tread类中的run()方法，此方法是线程的主体
            线程主体;
      }
}

注意：想要正确地启动线程，是不能直接调用run()方法的，而是应该调用Tread类中继承而来的start()方法。

2），实现Runnable接口

接口的定义：

public interface Runnable{
     public void run();
}

格式：

class 类名称 implements Tread{
      属性...;
      方法...:
      public void run(){     //覆写Runnable接口中的run()方法，此方法是线程的主体
            线程主体;
      }
}

3），Tread类与Runnable接口的区别

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

4），同步：

概念：所谓同步是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。

同步代码块：

代码块是指使用“{}”括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块，构造块，静态块3种，如果在代码块上加上synchronized关键字，则此代码块就称为同步代码块。

同步代码块的格式：

synchronized(同步对象){

           需要同步的代码；

}

同步方法：

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

         //方法体；

}