异常-Exception

• 指的是程序在执行过程中，出现的非正常的情况，影响了程序的正常执行

简单分类

• 检查性异常
  • 最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的（编译器会检查这类异常，提示你要去捕获并处理这种可能发生的异常，不处理就不能通过编译）。例如打开一个不在的文件等，这些异常在编译时不能被简单的忽略。
• 运行时异常
  • 是可能被程序员避免的异常（编译器不会检查这类异常）。与检查性异常相反，可以在编译时被忽略。
• 错误ERROR:
  • 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如栈溢出，编译检查不到

异常体系结构

• Java把异常当作对象来处理，定义了一个基类java.lang.Throwable作为所有异常的超类

• 异常分为两大类，错误Error和异常Exception
  

• Error

  • Error对象由Java虚拟机生成并抛出，大多数错误和代码编写者执行的操作无关
  • Java虚拟机运行错误（Virtual MachineError）,当JVM不带有执行操作所需的内存资源时，出现OutOfMemoryError。当异常发生，jvm一般终止线程
  • 在虚拟机试图执行应用是，发生类定义错误（NoClassDefFoundError)、链接错误（LinkageError）。这些错误不可察，在应用程序的控制和处理能力之外，大多数是程序运行是不允许出现的状况。-

• Exception

  • 该分支有一个重要的子类RuntimeException(运行时异常)
    • ArrayIndexOutOfBoundsException(数组下表越界)
    • NullPointerException(空指针异常)
    • ArithmeticException(算数异常)
    • MissingResourceException(丢失资源)
    • ClassNotFoundException(找不到类)等异常，这些异常是不检查异常，程序可以选择捕获处理，也可以不处理
  • 这些异常一般是程序逻辑错误引起的

• 两者区别

  • Error是灾难性的致命错误，程序无法控制和处理，当出现这些错误，JVM一般选择中止线程；Exception通常情况可以被程序处理，在程序中应该尽可能的处理这些异常。

异常的捕获与抛出

• 异常处理的5个关键字

  • try、catch、finally、throw,throws

  • Throwable是最高异常

  • 抛出异常不处理，捕获需要处理

  • 捕获

    • 假设捕获多个异常，只会执行一个异常。异常范围必须从小到大写或者互不相交，否则会报错

    • public abstract  class tea {
          public abstract  void run();
          public abstract  void stand();
      
          public static void main(String[] args) {
              int a=1;
              int b=1;
              try {  //try监控区域
                  System.out.println(a/b);
              }catch (ArithmeticException e) //catch捕获异常
              {
                  System.out.println("程序异常:b不能为0");
              }catch(Exception e)
              {
      
              }catch (Error e)
              {
      
              }catch (Throwable e)
              {
      
              }finally {  //finally都会被执行
                  System.out.println("finally");
              }
          }
      }
      

  • 抛出

    • 系统自动抛出

      • 运行出现错误自动抛出

    • throw

      • throw 指的是语句抛出异常，后面跟的是对象，如：throw new Exception，一般用于主动抛出某种特定的异常

      • public class ThrowTest {
        	
        	public static void main(String[] args) {
        		String string = "abc";
        		if ("abc".equals(string)) {
        			throw new NumberFormatException();
        		} else {
        			System.out.println(string);
        		}
        	}
        
        }
        

    • throws

      • throws 用于方法名后，声明方法可能抛出的异常，然后交给调用其方法的程序处理，如：

        public class ThrowTest {
        
        	public static void test() throws ArithmeticException {
        		int a = 0;
        		int b = 1;
        		System.out.println(b / a);
        	}
        
        	public static void main(String[] args) {
        		try {
        			test();
        		} catch (ArithmeticException e) {
        			// TODO: handle exception
        			System.out.println("test() -- 算术异常！");
        		}
        	}
        
        }
        

    • throw与throws的不同之处

      • throw 出现在方法体内部，而 throws 出现方法名后。
      • throw 表示抛出了异常，执行 throw 则一定抛出了某种特定异常，而 throws 表示方法执行可能会抛出异常，但方法执行并不一定发生异常。
      • throws是向上抛出

• 自定义异常

  • java内置的异常类可以描述出现的大部分异常情况

  • 自定义异常，需要继承Exception类

  • 步骤

    1. 创建自定义异常类
    2. 方法中通过throw，throws关键字抛出异常
    3. 如果在当前方法处理异常，使用try catch捕获异常，否则使用throws将异常抛出给调用者
    4. 在出现异常方法的调用者捕获并处理异常

  • package com.zhou;
    
    public class HelloWorld {
    
        public void test(int a) throws MyException{
            System.out.println("传递的参数为==>"+a);
            if(a>2)
            {
                throw new MyException(a);
            }
            System.out.println("OK");
        }
        /**
         * @param args
         */
        public static void main(String[] args) {
            HelloWorld helloWorld=new HelloWorld();
            try {
                helloWorld.test(1);
            } catch (MyException e) {
                System.out.println("异常"+e);
            }
        }
    }
    

  • package com.zhou;
    
    public class MyException extends Exception{
        private int a;
    
        public MyException(int a) {
            this.a = a;
        }
    
        /**
         *异常的打印信息
         * @return
         */
        @Override
        public String toString() {
            return "MyException{" +
                    "a=" + a +
                    ‘}‘;
        }
    }
    

  • 传递的参数为==>11
    异常MyException{a=11}

异常总结

• 对于异常要合理规避同时辅助try catch处理

• 在多重catch块后面，加一个Exeception来处理可能被遗漏的异常

• 对于不确定的代码，可以机上try-catch,处理潜在的异常

• 添加finally语句区释放占用的资源

原文：https://www.cnblogs.com/szZhouFeng/p/15251739.html