异常机制运行时异常、编译时异常 throws和throw的相同点和区别

异常机制

异常：程序在编译或运行过程中出现的错误
Throwable：Java中使用Throwable表示所有的异常
Java中异常分为两类：
1.Error：错误   一般是JVM或者是操作系统的问题
                   一旦发生，无法恢复
   常见的错误：
     IOError
    VirtualMachineError
    OutOfMemoryError [内存溢出或没有可用的内存提供给垃圾回收器时,抛出该错误]
    StackOverflowError [当应用程序递归太深而发生堆栈溢出时，抛出该错误]

2.Exception：异常主要是在程序运行期间发生的一些不正常事件中止了程序的运行，
                 可以通过JAVA异常处理机制捕获异常并处理，使得程序正常运行下去。
                 发生之后可以捕获并处理的
    常见的异常：
      编译时异常：
         IOException              输入输出流异常
         FileNotFoundException    文件找不到的异常
         ClassNotFoundException   类找不到异常
         DataFormatException      数据格式化异常
         NoSuchFieldException     没有匹配的属性异常
         NoSuchMethodException    没有匹配的方法异常
         SQLException             数据库操作异常
         TimeoutException         执行超时异常


      运行时异常： RuntimeException
       ArrayIndexOutofBoundsException   数组越界异常
        ClassCastException               类型转换异常
        NullPointerException             空指针异常
        IllegalAccessException           非法的参数异常
        InputMismatchException           输入不匹配异常

Exception分两类 :
运行时异常，不需要强制处理     所有的RuntimeException的子类都是运行时异常
编译时异常，需要强制处理在Exception范围内,除了运行时异常的类都是编译时异常


如何处理编译时异常？
     方法一：将需要处理的代码块放在一个try...catch...中
        try{

                 //需要处理异常的代码
            }catch(XXXException ef){
                  ef.printStackTrace();
            }
         先try一下，如果try能够执行完，就说明没有发生异常，catch就不工作
          一旦在try的过程中出现异常，放弃执行try，马上转到执行catch
        在catch中可以捕获异常信息，根据异常信息进行补救措施
      方法二：在出现异常的方法上直接向上抛出异常
           void ff() throws XXXException
            [可以一直继续向上抛   直到主函数向上抛到JVM处理]

             注意：在catch和throws的时候如果不确定是什么异常
                         就直接写一个Exception(老大)


如何处理运行时异常？
       一般情况下，运行时异常是不用处理的
      在某些情况下，如果对发生异常的结果进行处理，也可以对运行时异常进行
    try...catch...


自定义异常：
   当程序出现意外的时候，可以抛出异常对象来结束程序
       抛出运行时异常对象
    RuntimeException ef=new RuntimeException("下标越界index:"+index+"
size:"+size());
    throw ef;

      对于编译时异常，同样可以抛出异常对象
           在方法定义的时候必须throws
      public void test(int t) throws Exception{
if (t < 0 || t > 100) {
Exception ef = new Exception("数据错误");
throw ef;
}
}

finally语句　
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以

指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型

是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口

。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。

总结：

1.运行时异常和编译时异常的区别
编译时异常要求对它进行显式的try..catch 捕获处理或者向上一层方法抛出,否则在编译期
间就显示错误.而运行时异常在编译阶段不予检查,语法上不会显示任何错误。

2.throws和throw的相同点和区别
区别：
1)throw 是手动抛出异常,throw new **Exception(); 抛出的是某一个异常类型的实例
2)throws 是方法抛出异常,写在方法声明处
public void show()throws **Exception.紧跟throws后的是异常类型，而非异常实例,且可以声明抛出多个异常,同时这些异常类型大多都为编译时异常类型。
3)throw 是程序员手动抛出异常，一般可用在某种流程控制，需要显示操作失误情况下可
对外抛出异常，进入catch代码块，明示操作有误等. 明确这个地方要抛出这个异常.
4)throws 方法抛出异常，通常是告知调用此方法者，本方法有可能抛出一个异常，在调用
时应当要进行异常监控。且因为throws方法抛出异常为编译时异常类型，这样在编译阶段就
要求用户调用时对编译时异常类型作出捕获[try..catch(){}语句块]，或者再次向上抛出。
5)throws可以单独使用，但throw不能.throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。
6）程序会在throw语句后立即终止，它后面的语句执行不到,然后在包含它的所有try块中
（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

相同点：
只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调
用处理。

3.如何对编译时异常进行处理
方法一：将需要处理的代码块放在一个try...catch...中
方法二：在出现异常的方法上直接向上抛出异常 [可以一直继续向上抛直到主函数向上抛到JVM处理]

Error:

public class Demo {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.change();       //StackOverflowError
	
//	while(true){
//	long[] a = new long[100000000];  //OutOfMemoryError
//     }
	}
	public void change(){
		change();
	   }	
  }

try...catch{}

public class Demo2 {

	public static void main(String[] args) {
	//先try一下，如果try能够执行完，就说明没有发生异常，catch就不工作
	//一旦在try的过程中出现异常，放弃执行try，马上转到执行catch
	//在catch中可以捕获异常信息，根据异常信息进行补救措施
		
	      try{
		   //创建一个读取文件数据的对象
   FileOutputStream f = new FileOutputStream("C:\\Users\\kowloon\\Desktop\\");
	     }catch(Exception ex){
		//输出异常信息
		//ex.printStackTrace();
		System.out.println("找不到文件！！请想别的办法");
		}
	}
}

throws

public class Demo3 {
	//在主函数中可以继续往上抛，抛给了JVM  
	public static void main(String[] args) throws Exception {
		Demo3 d = new Demo3();
		d.change();
	}	
	//将异常抛给调用change的方法处理  
	public void change()  throws Exception {
		read();
	}
	//将异常抛给调用read的方法处理   
	public void read()  throws Exception{
		FileOutputStream f = new FileOutputStream("C:\\Users\\kowloon\\Desktop\\");
	}
}

运行时异常

public class Demo4 {
	public static void main(String[] args) {

	// 生成随机数
	Random rd = new Random();
	int num = rd.nextInt(100);

	Scanner sc = new Scanner(System.in);
	int t = -1;

	System.out.println("请输入您猜的数字:");
	do {
		try {
			// 获得输入的数字
			t = sc.nextInt();
		} catch (Exception ef) {
	System.out.println("必须输入0~100的数字，请重新输入您猜的数字:");
		sc = new Scanner(System.in);
		continue;
			}

			if (t < num) {
				System.out.println("太小了");
			} else if (t > num) {
				System.out.println("太大了");
			}
		} while (t != num);
		System.out.println("您猜对了:" + t);
	}
}

自定义异常

public class Demo5 {
	//自定义运行时异常
	//在定义方法的时候，抛出运行时异常
	public void change(int t) {
	  if (t < 0 || t > 100) {
	    RuntimeException ef = new RuntimeException("数据错误");
	     throw ef;
		}

	}
	//自定义编译时异常
	//在定义方法的时候，抛出的不是运行时异常
	//在方法的后面，就必须要throws
	public void test(int t)  throws Exception{
		if (t < 0 || t > 100) {
			Exception ef = new Exception("数据错误");
			throw ef;
		}
	}
}

public class Demo5Test {
	public static void main(String[] args) {
		Demo5 d = new Demo5();
		d.change(200);

//      try {
//			d.test(200);
//		} catch (Exception ef) {
//			ef.printStackTrace();
//		}
		
	}

}

异常机制 运行时异常、编译时异常 throws和throw的相同点和区别

猜你喜欢

异常机制运行时异常、编译时异常 throws和throw的相同点和区别