Java第六次课程作业

1.Throwable的子类包含哪两类？简述Java Error类与Exception类的区别。
Throwable的子类包含Error类和Exception类；
Errow类：致命异常，表示系统发生了不可控的错误，程序无法继续进行，只能人工介入。
Exception类：非致命异常，程序可处理。分为受编辑器检测的checked的异常和不受编辑器检测的unchecked的异常。
2.Exception又分为checked异常和unchecked异常，请分别举例说明。
checked异常：

class A{
	public static void main(String[]args)
	{
		try(Scanner sc=new Scanner(System.in)){
			int a=sc.nextShort();
		} catch(Exception e){
			e.printStackTrace();
		}
	}
}

unchecked异常：

class B{
	public static void main(String[]args){
		int []b;
		System.out.println(b[0]);
	}
}

3.简述StackOverflowError和OutOfMemoryError两类错误的发生情形和原因。
StackOverflowError发生的原因是线程调用生成的栈桢深度超过了虚拟机允许的深度；其发生的情形有递归的不断调用和不断的创建新的线程。
OutOfMemoryError发生的原因是系统内存不够，发生了内存溢出的情况；其发生的情形有栈的深度可以自动拓展，拓展的时候没有办法申请新的内存空间；如果在堆中没有完成实例分配并且堆也无法继续拓展的时候；还有方法区没法满足内存需求的时候；常量池没法申请更多的内存时；动态拓展时。
4.简述异常处理的两种方式，并举例说明区别
异常处理包括声明抛出处理和程序捕获处理两种方式。声明抛出处理包括隐式声明抛出和显式声明抛出，程序捕获处理包括非嵌套捕获和嵌套捕获。
隐式声明抛出：异常类型是RuntimeException或是其子类，程序方法可以对异常不作任何声明抛出或处理，直接交给调用该方法的地方处理，程序能编译通过，不会对可能产生异常的代码给出提示。

import java.io.*;
class TestScreenIn{
    public static void main(String[] args) {
        BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
        String c1;
        int i = 0;
        String[] e = new String[10];
        while(i<10){
            c1 = keyin.readLine();
            e[i] = c1;
            i++;
        }
    }
}

显式声明抛出：

import java.io.*;
class TestScreenIn{
    public static void main(String[] args) throws IOException {
        BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
        String c1;
        int i = 0;
        String[] e = new String[10];
        while(i<10){
            c1 = keyin.readLine();
            e[i] = c1;
            i++;
        }
    }
}

5.选取RuntimeException类的五个子类，编写抛出并捕获上述子类异常的程序。（例如算术异常，空指针异常，类转换异常，数组越界异常等）
算数异常：

public class arithmeticException {
    public static void main(String args[]){
        int a, b, c;
        a = 9;
        b = 0;
        c = 8;
        System.out.println(a / b + c);
    }
}

空指针异常：

public class nullException {
    private static int[] x;
    public static void main(String args[]){
        System.out.println(x[0]);
    }
}

类转换异常：

public class classCastException {
    static class One {
        public void foo() {
            System.out.println("One");
        }
    }
    static class Two extends One {
        public void foo() {
            System.out.println("Two");
        }
        public void dosth(){
            System.out.println("Two again");
        }
    }
    public static void main(String[] args) throws Exception{
        One t = new Two(); 
        t.foo();
        t.dosth();
        t = (Two)t;
        t.dosth();
        ((Two) t).dosth();
    }
}

数组越界：

public class listException {
    public static void main(String args[]){
        String foo  = args[1];
        System.out.println("foo = " + foo);
    }
}

空栈异常：

import java.util.Stack;

public class stackException {
    public static void main(String args[]){
        Stack stack = new Stack();
        Object ob = stack.pop();
    }
}

6.根据某业务场景自定义一个异常类，并在某场景下抛出该异常对象。

public class yicang extends Exception{
	yicang(String ms){
		super(ms);
	}

	static void Throw() throws yicang {
		int a=0,b=3;
		if(a!=0) {
			System.out.println(b/a);
		}
		else{
			throw new yicang("除数不能为0");
		}
	}
	public static void main(String []args) {
		try
	   	 {Throw();}
		catch(yicang e) {
			e.printStackTrace();
		}

}

7.异常中的throws声明与throw语句的区别是什么？请举例说明。
throw指的是语句抛出了一个异常，如下。

	private void checkIndex(int index) {
		if (index <= size - 1 && index >= 0) {
		} else {
			throw new IndexOutOfBoundsException("index:" + index + "  size:"
					+ size);
		}

	}

throws指的是方法可能会抛出的异常的声明，如下

	public static void fileCopy(String from, String to) throws IOException {
		// 1、建立联系 file对象。源：存在且为文件+目的地：文件可以不存在
		File fromPath = new File(from);
		File toPath = new File(to);
		fileCopy(fromPath, toPath);
	}

8.finally子句的作用是什么？
它的作用是：不论是否抛出异常都会执行，即使在有返回值并且已执行return语句后，也会执行finally语句块，但return返回的结果不会改变。