Java基础学习-异常的理解

• 异常：的根父类是：Throwable
•      
• 两个子类：Error 、 Exception
•       
•           Error：java虚拟机无法解析的严重问题。如：JVM系统内部的错误、资源耗尽等严重问题
•                  ， 一般不编写针对性的代码进行处理，即回去改代码，这里处理不了了。
•                例如：StackOverflowError (栈内存溢出)、OutOfMemoryError (堆内存溢出)
•           Exception：其他因编程错误，或偶然在外部因素导致的一般性问题，需要使用针
•                             对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂 掉。
•        
•                  例如：空指针访问、试图读取不存在的文件、网络连接中断、数组角标越界
•                - 编译时异常：（受检异常）在执行javac.exe命令时，出现异常
•                - 运行时异常：（非受检异常）在执行java.exe命令时，出现异常
•       
• 常见的异常：
•             - ArrayIndexOutOfBoundsException  数组角标越界
•             - NullPointerException  空指针异常
•             - ClassCastException  类型转换异常
•             - NumberFormatException  数据类型异常
•             - InputMismatchException  数据不匹配异常
•             - ArithmeticException  算数异常
•       
• 异常处理的方式：
•             I--- try-catch-finally
•                >语法格式：
•                    try{}
•                    catch{}
•                    catch{}
•                    catch{}
•                     ...
•                    finally{}
•                >使用细节：
•                    - 将可能出现异常的代码声明在try语句中，就会自动生成一个
•                               对应的异常的对象，将此对象抛出，
•                    - 针对于try抛出的异常类的对象，使用之后的catch语句进行匹
•                               配，一旦匹配上，就进入语句块中进行处理，一旦处理结束，代码就可以继续
•                             向下执行。
•                    - 如果声明了多个catch结构，不同的异常类型在不存在父子关
•                      系的情况下，谁生声明在上面，谁声明在下面都可以；但是
•                     如果满足了父子关系，则必须将子类声明在父类结构的上
•                     面。否则，报错。
•                       
•                    - 可以嵌套使用try-catch结构
•       
•                >catch中异常处理方法：
•                    - 自己编写输出语句
•                    - printStackTrace（）：打印异常信息（一般都用这种方式）。 
•                    - getMessage（）：获取发生异常的原因。
•                >try中声明的变量出了try结构后就不能调用了。
•       
•                >finally的理解
•                    - 我们将一定要被执行的代码声明在finally结构中。
•                    - 更深刻的理解：无论try中或catch中是否存在尚未被处理的异
•                        常，无论try中或catch中是否存在return语句等，finally
•                        中声明的语句都一定要把被执行。
•                       
•             - 但是注意：唯一的例外：使用System.exit(0);来终止当前正在运行的java虚拟机
•              
•                >catch和finally是可以有可以没有的，但是finally是不能单独使用的。
•       
•             I--- throws
•                》格式：在在方法的声明处，使用“throws 异常类型1，异常类型2，...”
•                        例如：public void test()throws 异常类型1，异常类型2，...{  可能存在编译错误   }
•      
•                》注意：在方法重写时，用throws抛出的编译时异常，一定要是其父
•                            类的要重写的方法抛出的异常相同，或者是子类，即，
•                             如果父类的方法没有抛出异常，则子类中重写的该方法也不
•                             能抛出异常，如果父类的方法抛出了异常，则子类重写的方
•                             法所抛出的异常要与父类异常相同，或者是其的子类，否则 会出错。
•                                
• 例如：如果是多态：person p = new man();
•                此时调用方法，时要解决方法可能抛出的异常，但是由于创建的是父
•                 类的对象只能捕获父类所抛出的异常，但是，执行的是子类中重写发
•                 的方法，该方法如果抛出的异常大于父类的异常，则虽然编译通过，
•                 但是运行时一旦抛出异常就会直接挂掉，因为没有解决。但是，可以
•                 抛出运行时异常（随便抛）。
•                                              
• 手动抛出异常
•                - throw：可以抛出异常
•                - 举例：（详见ThrowTest）
•      

• public class ThrowTest 
  {
  	public static void main(String[] args) 
  	{
  		students s = new students();
  		s.re(-10);
  		System.out.println(s);
  	}
  }
  
  class students
  {
  	int id;
  	public void study()
  	{
  		System.out.println("学生学习");
  	}
  	
  	public void re(int id)
  	{
  		if(id > 0)
  		{
  			this.id = id;
  		}
  		else
  		{
  			throw new RuntimeException("id不能为负数");  //抛出的是运行时的异常，不需要解决
  		}
  	}
  
  	@Override
  	public String toString() {
  		return "students [id=" + id + "]";
  	}	
  }

•              throw 和 throws 的区别：
•                - throw：是创建异常对象，手动抛出异常的对象。
•                - throws：是异常处理的一种方式。用来解决可能出现的异常。
•      
•      
• 自定义异常：
•             1. 如何自定义异常：
•                - 继承于现有的异常体系。通常继承于：RuntimeException（不需要解决） \ Exception
•                 （需要解决）
•                 - 通常提供几个重载构造器
•                 - 提供一个全局常量，声明为：atatic final longserialVersionUID
•         2. 如何使用自定义的异常类：
•                - 子啊具体的代码中，满足指定的条件的情况下，需要手动使用
•                 “throw + 自定义异常类的对象”方式，将异常对象抛出
•                - 如果自定义异常类是非运行时异常，则必须考虑如何处理此异常对
•                 象。（具体：① try-catch-finally ② throws）
•         3. 为什么需要自定义异常类型：
•                - 我们其实更关心的是，通过异常的名称就能直接判断此异常出现的
•                 原因。既然如此，那我们就有必要在实际的开发中
•                当不满足我们指定的条件时，指明自己特有的异常类，通过异常类的
•                 名称，就能知道问题的所在。
•         4.举例（详见Custom_Exception_Test）

• public class Custom_Exception_Test 
  {
  	public static void main(String[] args) 
  	{
  		try
  		{
  			person p = new person("张三",-12);
  			System.out.println(p);  //由于上一行报错了，因此这一行不执行
  		}
  		catch(NoNegativeNumber e)
  		{
  			e.printStackTrace();  //打印错误的具体信息  
  		}
  		finally
  		{
  			System.out.println("必须执行的语句!");
  		}
  		
  		System.out.println("以上异常解决，此语句执行");  //因为错误已经被处理，因此这一行执行
  //		System.out.println(p); //不能用 p 因为 p 的对象创建在 try 中，因此出了大括号就不能再使用了。可以将对象
  		//外面（try的外面）声明，在里面赋值,但是赋的值也带不出去
  	}
  }
  
  class NoNegativeNumber extends Exception  //自定义异常类，必须继承于RuntimeException（不需要处理） \ Exception（需要处理）
  {
  
  	 static final long serialVersionUID = 54994165L;  //要有，唯一标识
  	
  	public NoNegativeNumber()   //重载父类的构造器
  	{
  		super();
  	}
  
  	public NoNegativeNumber(String message)  //当对象调用e.printStackTrace();可以打印出括号里的信息
  	{
  		super(message);
  
  	}
  	
  }
  
  
  class person
  {
  	String name;
  	int id;
  	public person() 
  	{
  		super();
  	}
  	public person(String name, int id)  throws NoNegativeNumber //解决异常的方法（抛给调用此方法的方法）
  	{
  		super();
  		this.name = name;
  		if(id < 0)
  		{
  			throw new NoNegativeNumber("输入的id为负数！");  //手动抛出异常，因为重写了
  		}													  //public NoNegativeNumber(String message)构造方法
  		else												  //所以可以输入字符串
  		{
  			this.id = id;
  		}
  	}
  	@Override
  	public String toString() {
  		return "person [名字：" + name + ", 编号：" + id + "]";
  	}
  }