黑马程序员----java面向对象04（异常、包）

一.异常的概述

/*
 * 异常：就是程序在运行过程中出现不正常情况
 *
 * 异常由来：问题也是现实生活中的一种事物，也可以通过java的类的形式进行描述，并封装成对象
 *    异常也就是java对不正常现象进行描述后的对象体现
 *
 * 问题分为两种，一种是严重的问题;一种是非严重的问题
 *  对于严重的，java通过Error类进行描述（癌症）
 *  对于非严重的，java通过Exception进行描述（感冒发烧）
 *
 * 异常处理代码格式
 * try{
 *   需要被检测的代码
 * }
 * catch(异常类   变量){
 *   处理异常的代码
 * }
 * finally{
 *   一定会执行的代码
 * }
 *
 * */
代码示例：

public class ExceptionDemo {
	public static void main(String[] args) {
		Demo1 d = new Demo1();
		try{
			System.out.println(d.show(3,0));
		}
		catch(Exception e){
			System.out.println("除数为零啦");
			System.out.println("------------");
			System.out.println(e.getMessage());
			System.out.println("------------");
			System.out.println(e.toString());
			System.out.println("------------");
			e.printStackTrace();
		}
		finally{	
		}	
	}	
}

class Demo1{
	int x =4;
	int show(int a,int b){
		return a/b;
	}
}

 

 

二.多异常情况

/*
 * 多异常情况的出现
 * 1、如果有多个异常，当第一个异常出现时程序就会停止
 * 2、声明异常是在功能上
 * 3、声明异常时，声明更为具体的异常
 * 4、有几个异常就对应几个catch代码块
 * 5、如果多个catch块出现了继承关系，父类要放在最后执行  例如：Exception和ArrayIndexOutOfBoundsException
 *
 * */

代码示例：

public class ExceptionDemo2 {
	public static void main(String[] args) {
		Demo2 d = new Demo2();
		try {
			d.show(3, 1);
		} catch (ArrayIndexOutOfBoundsException abe) {
			
		} catch (ArithmeticException ae) {
			
		}
	}
}

class Demo2 {
	//在功能上通过throws关键字声明了该功能可能出现的异常
	public int show(int a, int b) throws ArrayIndexOutOfBoundsException,ArithmeticException{
		int[] num = new int[a];
		System.out.println(num[a]);
		return a/b;
	}
}

 

 

三.自定义异常

 /*
 * 自定义异常：
 * 异常中，有些问题未被java所描述并封装对象，所以对于这些特定的问题可以按照java封装对象的思想
 *  讲特有的问题进行自定义的异常封装
 *   也就是java中对有的问题没有解决办法的，要自己定义解决办法
 * 
 *  需求：对于本程序中，对于除数是负数也视为是错误的，是无法进行运算的，
 *   那么就需要对这个问题进行自定义的描述
 * 
 *  1、java中定义的异常可以自动抛出，也可以由手动抛出；自定义的异常只能手动抛出
 *  2、当在函数内部出现throw抛出异常时，就要给出对应的处理动作：要么在函数内部处理，要么抛出由调用者处理
 *  3、出现了问题，那么内部解决，要么抛出去
 * 
 * 
 *  throw和throws的区别
 *  1、throw定义在函数内；throws定义在函数上
 *  2、throw后面跟的是异常对象；throws后面跟的是异常类，可以是多个，用逗号隔开
 * 
 * */

 代码示例：

public class ExceptionDemo3 {
	public static void main(String[] args) {
		Demo3 d = new Demo3();
		try {
			d.show(9,-3);
		} catch (FuShuException fe) {   //接收抛出的异常对象
			System.out.println(fe.toString());   //打印异常信息
		}		
	}
}

//自定义异常
class FuShuException extends Exception{    //1、自定义异常类名后缀加上Exception,继承了异常类
	private String msg;
	FuShuException(String msg) {
		super(msg);
	}
	//这里隐藏了一句话，由于继承了Exception，所以也已经拥有了getMassage方法
}

class Demo3{
	void show(int a,int b) throws FuShuException{      //声明出现了异常
		if(b<0){
			throw new FuShuException("除数为负数的异常 /by fushu");   //手动抛出异常对象
		}
	}
}

 

 

 

四.异常示例（电脑讲课出现蓝屏和冒烟情况）

 /*
 * 老师用电脑上课的时候出现了问题，蓝屏和冒烟
 * */

public class ExceptionText {
	public static void main(String[] args) {
		Teacher t = new Teacher("毕老师");   //这样当老师产生的时候电脑也产生了
		try{
			t.teach();
		}catch(NoPlanException e){
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
	}
}

//老师类
class Teacher{
	private String name;
	private Computer c;
	Teacher(String name){
		this.name = name;
		c = new Computer();
	}
	//老师有一个讲课方法
	void teach() throws NoPlanException{
		c.Boot();
		System.out.println(name+"开始讲课");
		try{
			c.question();
		}catch(LanPingException e){
			System.out.println(e.toString());
			c.reset();
		}catch(MaoYanException e){
			throw new NoPlanException("电脑冒烟了，课时无法继续");  //抛出新异常
		}
	}
}

//电脑类
class Computer{
	//开机方法
	void Boot(){
		System.out.println("电脑开机");
	}
	//重启方法
	void reset(){
		System.out.println("重启电脑");
	}	
	//当电脑蓝屏时,假设当i=2时电脑蓝屏，当i=3时电脑冒烟
	int i=3;
	void question() throws LanPingException,MaoYanException{
		if(i==2){
			throw new LanPingException("电脑蓝屏了");
		}
		if(i==3){
			throw new MaoYanException("电脑冒烟了");
		}
	}
}

//蓝屏异常
class LanPingException extends Exception{
	public LanPingException(String message) {
		super(message);
	}
}

//冒烟异常
class MaoYanException extends Exception{
	public MaoYanException(String message) {
		super(message);
	}
}

//课时计划无法继续异常
class NoPlanException extends Exception{
	public NoPlanException(String message) {
		super(message);
	}
}

 

 

 

 

五.内部类

/*
 * 内部类：
 * 1、内部类可以直接访问外部类的成员，包括私有(相当于类中函数可以访问类中变量一样)
 *   原因：是因为内部类中持有了一个外部类的引用，格式为   外部类名.this.
 * 2、外部类要想访问内部类，必须建立内部类对象
 *   格式为：外部类名.内部类名    变量名 = 外部类对象.内部类对象;
 *
 * 什么时候使用内部类？
 *  ：当事物的内部还有事物时，并且内部事物可以直接访问外部事物中的内容时，就需要定义内部类，例如心脏类定义在人体类中，可以直接访问人体功能
 * */

代码示例：

public class InnerDemo { 
	public static void main(String args[]){
		Demo.Demo_Nei dn = new Demo().new Demo_Nei();    //例2
		}
	}


class Demo{
	private int x=4;
	
	class Demo_Nei{
		int x = 3;
		public void show(){
			int x =5;
			System.out.println("x的值为："+x);  //Demo.this.x   this.x   x
		}
	}
}

 

 

六.RunTimeException异常

/*
 * Exception子类中有个一个特殊的异常RunTimeException异常，运行时异常：
 * 特点：
 * 1、如果RunTimeException类或其子类在函数中抛出了，函数上是不需要声明的
 * 2、如果在函数中声明了该异常，调用者不需要进行处理（继续抛或者try）
 *
 * 之所以不需要在函数上声明，是因为不需要调用者去处理
 * 因为在运行过程中，出现了无法继续运算的情况，这时候需要对代码进行修正
 *
 *
 * RunTimeException类下的三个常见子类：
 *   ArithmeticException（算法异常）
 *   NullPointerException（空指针异常）
 *   IndexOutOfBoundsException（角标越界异常）
 * 
 *  定义异常类继承异常类，要么继承Exception，要么继承RunTimeException
 * */

 

 

 

七.finally关键字

public class Exception_Finally {
	public static void main(String[] args) {
		Demo d = new Demo();
		try {
			d.show(2,-9);
		} catch (FuShuException e) {
			System.out.println(e.getMessage());
			//return;
		}
		finally{
			//定义一定会执行的代码，通常用于关闭资源，例如关闭数据库
		}
		
		System.out.println("异常结束后会执行的代码");
		/*
		 * 这段代码和finally的区别：
		 * 如果在catch处理中return了，导致程序结束，那么这段代码就不会执行了，但finally仍然会执行
		*/
	}
}

//自定义一个异常
class FuShuException extends Exception{
	FuShuException(String msg) {
		super(msg);
	}
} 

class Demo{
	public void show(int a,int b) throws FuShuException{
		if(b<0){
			throw new FuShuException("除数是负数");
		}
	}
}

 

 

 

八.示例：求长方形和圆形的面积

/*
 * 需求：有一个圆形和长方形，都可以获取面积，对于面积如果出现非法的数值，那么视为面积出现了问题
 * */

代码示例：

 

public class Exception_shili {
	public static void main(String[] args) {
		
			Circle c = new Circle(-4.3);
			c.area();		
	}
}
//提取面积,用接口定义
interface Area{
	public abstract void area();//方法定义格式
}

//圆形
class Circle implements Area{
	private double radius;
	public static final double PI=3.14;
	
	Circle(double radius){
		if(radius<=0){
			throw new NoValueException("数值不合法");
		}		
		this.radius = radius;
	}
	
	public void area(){
		System.out.println("圆的面积是："+radius*radius*PI);
	}
}

//长方形
class Rectangle implements Area{
	private double length,width;	
	
	Rectangle(double radius){
		if(length<=0 || width<=0){
			throw new NoValueException("数值不合法");
		}		
		this.length = length;
		this.width = width;
	}
	
	public void area(){
		System.out.println("长方形的面积是："+length*width);
	}
}

//自定义异常
class NoValueException extends RuntimeException{
	private String massage;
	public NoValueException(String massage) {
		super(massage);
	}
} 

 

 

 

九.异常的总结

/*
 * 异常总结：
 * 1、什么是异常：是对问题的描述，将问题进行对象的封装
 * 2、异常体系：
 *   throwable
 *    |--Error   
 *    |--Exception
 *        |--系统异常
 *        |--RunTimeException
 *        |--自定义异常
 *  3、异常体系的特点：
 *   异常体系中的所有类和建立的对象都具有可抛性，可以被throws和throw关键字所操作
 *  4、throw和throws的区别：
 *   throws定义在函数上，用于抛出异常类,可以抛出多个异常，用逗号隔开
 *   throw定义在函数中，用于抛出异常对象
 *  5、当函数内容抛出异常时，要么就在内部捕获处理，要么就对其方法声明并抛出
 *   RunTimeException除外，要是抛出的是RunTimeException异常，那么可以不用声明
 *  6、如果函数声明了异常，调用者可以try处理，也可以继续抛出
 *  7、try三种格式
   try{
 *    
 * }catch(){
 *   
 * }
  ---------------------
   try{
   //定义被检测代码
   }catch(){
     //处理异常代码
   }finally{
     //一定会执行的代码
   }
   ---------------------
   try{
 
   }finally{
  
   }
    注意：finally中一般定义的是关闭资源的代码，只有一种情况是不会执行的：System.exit(0);
   
    8、自定义异常
    class MyException extends Exception{
     MYException(String message){
      super(message);
     }
    }
    好处：按照java面向对象思想，把程序中出现的特有问题进行封装
    9、异常的好处
     一，将问题进行封装
     二，将正常流程代码和问题处理代码分隔开来，利于阅读
 * */

public class Exception_zongjie {

}