黑马程序员——Java语言基础——03.面向对象（3）异常

------- android培训、java培训、期待与您交流！ ----------

本节考点：

一、throws和throw的区别：

1. throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。
2. throw用于抛出异常对象。
3. thorws用在函数上，后面跟异常类名。
4. throw用在函数内，后面跟异常对象。

二、try、catch、finally分别在什么情况下使用？
 *  （1）try语句：
 *  某段代码中可能抛出异常，将其放入try语句，用来检测异常。
 *  一旦发生异常就会跳转到catch，否则不会执行catch
 *  （2）catch语句：
 *  除非try语句中的代码发生异常，否则这里的代码不会执行，用来接收并处理
 *  try语句中发生的异常，参数中的异常类型必须是Throwable类的子类对象。
 *  （3）finally语句：
 *  finally所指定的代码一定会执行，它提供了统一的出口，用来存放
 *  一定会执行的语句，比如关闭线程等。

注意：

finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0)

三、final,finally,finalize区别。
 final是最终的意思。它可以用于修饰类，成员变量，成员方法。
它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。
finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。
四、假如catch中有return语句， finally里中的代码会执行吗？是在return前，还是在return后呢？
会，在return前执行finally里面的代码。

3-1 异常的概念

3-1-1 异常的体系

异常：是在运行时期发生的不正常情况。

在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。

1. 以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离，提高阅读性。
2. 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。
3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。
4. 问题很多，意味着描述的类也很多，将其共性进行向上抽取，形成了异常体系。

不正常情况分成了两大类：
Throwable：无论是error，还是异常、问题，问题发生就应该可以抛出，让调用者知道并处理。
     //该体系的特点就在于Throwable及其所有的子类都具有可抛性。
     可抛性到底指的是什么呢？怎么体现可抛性呢？
     其实是通过两个关键字来体现的。
     throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。

     |--1，一般不可处理的：Error
          特点：是由jvm抛出的严重性问题。
          这种问题发生，一般不针对性处理，直接修改程序。
     |--2，可以处理的：Exception
该体系的特点：
     子类的后缀名都是用其父类名作为后缀，阅读性很强。

Throwable中的方法：

1. getMessage()：获取异常信息，返回字符串。
2. toString()：获取异常类名和异常信息，返回字符串。
3. printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
4. printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class Chufa
{
	public int Shabi(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
	{
		int[] arr = new int[a];
		System.out.println(arr[3]);
		return a/b;
	}
}

class ExceptionDemo
{
	public static void main(String[] args)
	{
		Chufa c = new Chufa();
		try
		{
			int result = c.Shabi(4,0);
			System.out.println("结果："+result);
		}
		catch (ArithmeticException a)
		{
			System.out.println(a.toString());
			System.out.println("除数为零");
		}
		catch (ArrayIndexOutOfBoundsException a)
		{
			System.out.println(a.toString());
			System.out.println("角标越界异常");
		}
		System.out.println("game over");
	}
}</span>

3-1-2 自定义异常

可以自定义出的问题称为自定义异常。

对于角标为负数的情况，准备用负数角标异常来表示，负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。

这种自定义的问题描述称为自定义异常。

注意：

如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作，throws、throw。

自定义类继承Exception或者其子类，通过构造函数定义异常信息。

示例：
Class DemoException extends Exception
{
     DemoException(String message)
     {
          super(message);
     }
}
通过throw将自定义异常抛出。

throws和throw的区别：

1. throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。
2. throw用于抛出异常对象。
3. thorws用在函数上，后面跟异常类名。
4. throw用在函数内，后面跟异常对象。

定义功能方法时，需要把出现的问题暴露出来让调用者去处理，那么就通过throws在函数上标识。
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class myException extends Exception
{
	myException(String message)
	{
		super(message);
	}
}

class Chufa
{
	public int Chu(int a,int b) throws myException
	{
		if (b < 0)
		{
			throw new myException("除数为负数");
		}
		if (b == 0)
		{
			throw new myException("除数为0");
		}
		return a/b;
	}
}

class MyExceptionDemo 
{
	public static void main(String[] args) 
	{
		Chufa a = new Chufa();
		try
		{
			int result = a.Chu(4,0);
			System.out.println("结果为："+result);
		}
		catch (myException m)
		{
			System.out.println(m.toString());
			System.out.println("异常信息为:"+m.getMessage());
		}
		
		System.out.println("game over");
	}
}</span>

异常的分类：
1，编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。

2，编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法运行，更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行调整。
所以自定义异常时，要么继承Exception，要么继承RuntimeException。

异常处理的捕捉形式：
可以对异常进行针对性处理的方式。
具体格式是：
try{
     //需要被检测异常的代码。
}
catch(异常类 变量) //该变量用于接收发生的异常对象
{
     //处理异常的代码。
}
finally{
     //一定会执行的代码；
}

注意：

finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0)。

处理过程：
try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。
finally里通常用来关闭资源。比如：数据库资源，IO资源等。
需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。
如果在try以外继续使用，需要在try外建立引用，在try中对其进行初始化。IO，Socket就会遇到。

异常处理的原则：

1，函数内容如果抛出需要检测的异常，那么函数上必须要声明。
否则，必须在函数内用try/catch捕捉，否则编译失败。

2，如果调用到了声明异常的函数，那么try/catch，要么throws，否则编译失败。

3，什么时候catch，什么时候throws呢？
功能内容可以解决，用catch。
解决不了，用throws告诉调用者，由调用者解决。

4，一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性处理。
内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class Chufa
{
	public int div(int a,int b) throws FushuException
	{
		if(b < 0)
			throw new FushuException("除数为负数");
		return a/b;
	}
}

class FushuException extends Exception
{
	FushuException(String message)
	{
		super(message);
	}
}

class FinallyDemo
{
	public static void main(String[] args)
	{
		Chufa c = new Chufa();
		try
		{
			int result = c.div(4,-1);
			System.out.println("结果："+result);
		}
		catch (FushuException f)
		{
			System.out.println(f.toString());
		}

		finally
		{
			System.out.println("game over");
		}
	}
}</span>

try catch finally 代码块组合特点：
1，try catch finally
2，try catch(多个)当没有资源需要释放时，可以不用定义finally。
3，try finally 异常无法直接catch处理，但是资源必须关闭。

示例：

void show() throws Exception{
     try{
          //开启资源
          throw new Exception();
     }finally{
          //关闭资源
     }
}

异常综合示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class BlueScreenException extends Exception
{
	BlueScreenException(String message)
	{
		super(message);
	}
}

class SmokeException extends Exception
{
	SmokeException(String message)
	{
		super(message);
	}
}

class Computer
{
	private int state = 2;
	public void run() throws BlueScreenException,SmokeException
	{
		if(state == 2)
			throw new BlueScreenException("电脑蓝屏");
		if(state == 3)
			throw new SmokeException("电脑冒烟");
		System.out.println("电脑运行");
	}

	public void reset()
	{
		state = 1;
		System.out.println("电脑重启");
	}
}

class Teacher
{
	private String name;
	private Computer comp;

	Teacher(String name)
	{
		this.name = name;
		comp = new Computer();
	}

	public void prelect()
	{
		try
		{
			comp.run();
		}
		catch (BlueScreenException b)
		{
			comp.reset();
		}
		catch (SmokeException s)
		{
			comp.reset();
		}
		
		System.out.println("讲课");
	}
	
}

class ExerciseException
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("毕老师");
		t.prelect();
	}
}</span>

异常的注意事项：
1，RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。

2，子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
3，如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类的子集。

注意：

如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

3-2 Object类

Object ：所有类的根类。
Object是不断抽取而来，具备着所有对象都具备的共性内容。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person{
       private int age ;
      Person( int age){
             this.age = age;
      }
}

class Demo{
}

class ObjectDemo{
       public static void main(String[] args){
            Person p1 = new Person(20);
            Person p2 = new Person(20);
            Person p3 = p1;
      
            Demo d = new Demo();

            System. out.println(p1 == p2);//false
            System. out.println(p1.equals(p2));//false
            System. out.println(p1.equals(p3));//true
            System. out.println(p1.equals(d));//false
      }
}</span></span>

Object类的toString方法默认返回的内容是“对象所属的类名+@+对象的哈希值（十六进制）”

下面例子中两句输出语句结果相同

<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person{
       private int age ;
      Person( int age){
             this.age = age;
      }
       public int hashCode(){
             return age ;
      }
}

class ObjectDemo{
       public static void main(String[] args){
            Person p1 = new Person(20);

            System. out.println(p1);
            System. out.println(p1.getClass().getName() + "$" + Integer.toHexString(p1.hashCode()));
      }
}</span></span>

3-3 包

3-3-1 包(package)

1、对类文件进行分类管理。
2、给类提供多层命名空间。
3、写在程序文件的第一行。
4、类名的全称的是  包名.类名。
5、包也是一种封装形式。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">package package1;
/*
使用包来保存编译之后的class文件，编译时使用命令
javac -d . TestPackage.java  即可保存在首句已定义的文件名中，并新建文件夹
其中的 . 可以替换为“c:\workspace”之类的文件夹名称

如果两个文件将会编译在同一个包，则不存在相互访问的问题，直接编译其中一个就行了
*/

public class TestPackage
{
	public static void main(String[] args)
	{
		package2.Demo a = new package2.Demo();
		a.show();
		System.out.println("shabi");
	}
}
</span>

包与包之间的类进行访问，被访问的包中的类必须是public的，被访问的包中的类的方法也必须是public的。

被访问的包中的类权限必须是public的。
类中的成员权限：public或者protected
protected是为其他包中的子类提供的一种权限。

3-3-2 Jar包

Java的压缩包。
方便项目的携带。
方便于使用，只要在classpath设置jar路径即可。
数据库驱动，SSH框架等都是以jar包体现的。

Jar包的操作

通过jar.exe工具对jar的操作。
创建jar包
jar  -cvf  mypack.jar  packa packb
查看jar包
jar  -tvf  mypack.jar   [>定向文件]
解压缩
jar  -xvf  mypack.jar
自定义jar包的清单文件
jar –cvfm  mypack.jar  mf.txt  packa packb

------- android培训、java培训、期待与您交流！ ----------