【黑马程序员】面向对象（六） 第十天

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------

知识点

01）异常-finally

public class FinallyExceptionDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		try{
			int a = d.div(5, -1);
			System.out.println("A: " + a);
		}catch(FuShuException e){
			System.out.println(e.getMessage());
			return;//结束主函数。
		}finally{//一定会执行的代码。
			System.out.println("finally");
		}
		System.out.println("-----------");
	}
}
class FuShuException extends RuntimeException{
	FuShuException(String mag){
		super(mag);
	}
}
class Demo{
	int div(int a, int b){
		if (b < 0)
				throw new FuShuException("除数出现负数");
		return a / b;
	}
}

运行结果如下图所示：

02）异常—处理语句其它格式

共有三种格式：

/*
 * 三种格式：
 * 第一种：
 * try{
 * }catch(){
 * }
 * 第二种：
 * try{
 * }catch(){
 * }finally{
 * }
 * 第三种：
 * try{
 * }finally{
 * }
 * 
 * 注意：catch是用于处理异常。如果没有catch就代表异常没有被处理过。如果该异常是检测时异常，那么必须声明。
 */

03）异常—覆盖时的异常特点。

/*
 * 异常在子父类覆盖中的体现：
 * 1：子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或该异常的子类或者不抛。
 * 2：如果父类抛出多个异常，那么子类在抛出异常时，只能抛出父类的子集。
 * 3：如果父类或接口的方法中没有抛出异常。那么子类在覆盖父类的方法时，也不能抛出异常。
 * 			如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
 */
public class E_2 {
	public static void main(String[] args) {
		Test t = new Test();
		try{
			t.function(new Zi());
		}finally{
			System.out.println("-----------");
		}
	}
}
class Test{
	void function(Fu f){
		try{
			f.show();
		}catch(AExc e){
		}
	}
}
class Fu{
	void show() throws AExc{
		System.out.println("Fu");
	}
}
class Zi extends Fu{//子类
	void show() throws BExc{//覆盖父类的方法，但只能抛A异常或者B异常。
		System.out.println("Zi");
	}
}
class AExc extends Exception{//
//	AExc(String mag){
//		super(mag);
//	}
}
class BExc extends AExc{//BExc是父类AExc的子类异常
//	BExc(String mag){
//		super(mag);
//	}
}

运行结果如下：

Zi
-----------

04）异常练习

/*
 * 一个圆和一个长方形。
 * 都可以获取面积。如果面积小于等于0，则视为面积出现了问题。
 */
public class ExceptionTest_1 {
	public static void main(String[] args) {
//		try{
//			Rec b = new Rec(3, -2);
//			b.getArea();
//		}catch(NovalueException e){
//			System.out.println(e.getMessage());
//		}
//		System.out.println("----------------");
		Circle c = new Circle(-3);//创建一个圆对象。
		c.getArea();//调用getArea()方法获取圆面积。
	}
}
interface sharp{//接口
	void getArea();
}
class Rec implements sharp{//实现sharp接口。
	private int len, wid;
	Rec(int len, int wid){
		if (len <= 0 || wid <= 0)//如果长和宽有一个不大于0，则抛出异常。
			throw new NovalueException("出现长和宽不大于零异常");
		try{
			this.len = len;
			this.wid = wid;
		}catch(NovalueException e){
			
		}

	}
	public void getArea(){//获取长方形面积。
		System.out.println("长方形面积为： " + len * wid);
	}
}

class Circle implements sharp{//实现sharp接口。
	private double radius;
	Circle(double radius){
		if (radius <= 0)//如果半径不大于零则抛出异常。
			throw new NovalueException("出现半径为不大于零异常");
		try{
			this.radius = radius;
		}catch(NovalueException e){
			
		}
		
	}
	public void getArea(){//获取圆面积
		System.out.println("圆面积为: " + Math.PI * radius * radius);
	}
}

class NovalueException extends RuntimeException{
	NovalueException(String mag){
		super(mag);
	}
}

运行结果如下图所示：

05）异常—总结

是什么？是对问题的描述。将问题进行对象的封装。

异常体系：

Throwable

|——Error

|——Exception

|——RuntimeException

异常体现的特点：异常体系中的所有类以及建立的对象都具备可抛性。

也就是说可以被throw和throws关键字所操作。

只有异常体系具备这个特点。

throw和throws的用法：

thorw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

-----------------------------------------------------------------------------------------------------

当函数内容有throw抛出异常（RuntimeException异常及子类除外）时，并为进行try处理。必须要在函数上声明，否则编译失败。

如果函数声明了异常，调用者需要进行处理。处理方式可以throws和try。

异常有两种：

编译时被检测异常：该异常在编译时，如果没有被处理（没有抛没有try），那么编译失败。

运行时异常（编译时不检测）：RuntimeException，在编译时不需要处理，编译器不检查。该异常发生时，建议不处理，让程序自动停止。需要对代码进行修正。

-----------------------------------------------------------------------------------------------------

 finally：

1：finally中定义的通常是，关不资源代码。因为资源需要被释放。

2：finally中只有一种情况不会执行。当代码到System.exit(0);finally不会执行。

-----------------------------------------------------------------------------------------------------

自定义异常：

定义类继承Exception或者RuntimeException

1：为了让该自定义类具备可抛性。

2：让该类具体操作异常的共性方法。

当要自定义异常的信息时，可以使用父类已经定义好的功能。

class MyException extends Exception{
      MyException (String mag){
               super(mag);
      }
}

自定义异常：按照Java的面向对象思想，将程序中出现的特有问题进行封装。

-----------------------------------------------------------------------------------------------------

异常的好处：

1：将问题进行封装。

2：将正常流程代码和问题处理代码相分离，方便阅读。

异常的处理原则：

1：处理的方法有两种：try或者throws。

2：调用到抛出异常的功能时，抛出几个，就处理几个。

一个try对应多个catch的情况。

3：多个catch，父类的catch放在最下面。

4：catch内，需要进行针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要什么不写。

当捕获到异常，本功能处理不了时，可以继续再catch中抛出。

如果该异常处理不了，但并不属于该功能的异常。可以将异常转换后，再抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题抛出去，当调用着知道并处理。也可以将捕获异常处理后，转换新的异常。

异常的注意事项：

在子类覆盖父类时：

1：子类抛出的异常必须是父类异常的 子类或子集。

2：如果父类或者接口没有抛出异常时，子类覆盖出现异常，只能try，不能抛。

-----------------------------------------------------------------------------------------------------

07）package包

对文件进行分类管理。

给类提供多层命名空间。

写在程序文件的第一行。

类名的全称是 包名.类名

包也是一种封装形式。

附言：我是Java新人，如有错误的地方请指出。

                         每天学习一点点，纠错一点点，进步很大点。

-------  android培训、java培训、java学习型技术博客、期待与您交流！ ----------