黑马程序员----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 {

}