复习，自定义异常，运行异常，编译时异常，finally块

内部类：

内部类的类别：

　　成员内部类：在一个类的成员位置定义另一个类，那么另一个类就称作为成员内部类

　　　　　　成员内部类的访问方式：

　　　　　　　　　　方式一：在外部类内提供一个方法创建内部类的对象进行访问

 

　　　　　　　　　　方式二：在其他类创建内部类的对象进行访问，创建的格式：　　外部类.内部类 变量名 = new 外部类();

　　

　　　　　　　　　　注意：如果是静态内部类在其他类创建对象方式：　　外部类.内部类 变量名 = new 外部类.内部类();

成员内部类要注意的细节:

　　　　1,成员内部类可以直接访问外部类成员。

　　　　2，如果成员内部类与外部类存在同名的成员，在内部类中默认是访问内部类的成员。

　　　　　　成员通过“外部类.this.成员”指定范根外部类的成员，

　　　　3，如果成员内部类出现了精态的成员，那么该成员也必须使用static修饰。

　　　　4，如果成员内部类是私有的，那么创建内部类的对象就只能在外部类提供方法创建、

 

 

　　局部内部类：　　在一个类的方法内部定义另一个类，另一个类就称作为局部内部类。

变量

　　局部内部类要注意： 如果局部内部类访问了局部变量，那么该变量需要fianl修饰（原因：因为生命周期不一致，所以内部类访问局部变量的其实是一个复制品）

 

 

　　匿名内部类：没有类名的类

　　

　　匿名内部类的好处：简化书写。

 

　　匿名内部类的使用前提：必须存在继承过着实现关系，

 

　　匿名内部类的格式：

　　　　new 父类（父类接口）{

　　　　匿名内部类的成员；

}；

异常：

异常的体系：

——————】Throwable

————————】 Error（错误）　　错误一般是由于jvm或者是硬件引发的问题。所以我们一般不会通过代码取处理。

————————】 Exceptiom（异常）异常我们一般都会通过代码去处理。

异常处理的方式：

　　　　方式一：捕获处理

　　　　捕获处理的格式：

　　　　　　　　try{

　　　　　　　　　　　　可能发生异常的代码

}catch（捕获的异常类型 变量名）{

　　处理异常的代码

}

捕获处理亚注意的细节：

　　1，如果一个try块中出现了异常的代码，经过处理后，那么try-catch块外面的代码可以运行。

　　2，如果一个try块中出现了异常代码，那么在try块中出现异常的代码后面的d语句无法执行、

　　3，一个try块后面可以跟着多个catch块，也就是一个try块可以捕获多种异常类型，但是捕获的异常必须从小到大进行捕获。

　　方式二：抛出处理（throw throws）

 

抛出处里要出注意的细节：

　　1，如果一个方法内部抛出了一个异常对象，那么该方法必须声明抛出，

　　2,如果调用了一个声明抛出异常的方法，那么调用者必须要处理。

　　3，如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）

　　4，在一种情况下只能抛出一种异常   对象

throw关键字适用于方法体内抛出异常对象的，throws是用于方法声明上声明抛出异常类型的。

sun提供了很多的异常类型给我们用于描述程序中各种不正常的情况，但是sun给我们提供异常类型还不足以描述我们现实生活中所有不正常情况，那么这时候我们就需要自定义异常类。

需求：模拟feiq上线的时候，如果没有插上网线，那么就需要抛出一个没有插上网线的异常，如果已经插上网线，那么正常显示好友列表。

代码示例：

import org.omg.Messaging.SYNC_WITH_TRANSPORT;
class NolpException extends Exception{
    public NolpException(String message){
        super(message);
    }
}
public class Demo38 {
    public static void main(String[] args) {
        String ip = "111.134.12.123";
        try {
            feiQ(ip);
        }catch (NolpException e){
            e.printStackTrace();
            System.out.println("马上插上网线");
        }
    }
    public static void feiQ(String ip)throws NolpException{
        if (ip==null){
            throw new NolpException("没有插上网线");

        }
        System.out.println("正常显示好友");
    }
}
运行结果：

 

异常的体系：

——————】Throwable

————————】 Error（错误）　　错误一般是由于jvm或者是硬件引发的问题。所以我们一般不会通过代码取处理。

————————】 Exceptiom（异常）异常我们一般都会通过代码去处理。

——————————】运行时异常：如果一个方法内部排除一个运行时异常，那么方法上可以声明也可以不声明，调用者可以处理也可以不处理。

——————————】编译时异常（非运行异常，受检异常）：如果一个方法内部抛出一个编译时异常对象，那么方法上就需要声明，而且调用者也必须要处理。

运行时异常：RuntimeException以及RuntimeExceotion子类都是属于运行异常。

编译时异常：除了运行时异常就是编译时异常。

疑问：为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？

　　　运行时异常都是可以通过程序员良好的编程习惯去避免。所以java编译器就没有严格要求处理运行时异常。

代码演示：

public class Demo39 {
    public static void main(String[] args){
        int[] arr = null;
        div(4,2,arr);

    }
    public static void div(int a,int b,int[] arr){
        if (b==0){
            return;
        }
        int c = a/b;
        System.out.println("c = "+c);
        if (arr!=null){
            System.out.println("数组的长度"+arr.length);
        }
    }
}
运行结果：

 

 finally块；

finally块的使用前提是必须存在try块才能使用。

finally块的代码在任何情况下都可以执行，除了jvm退出的情况下

finally非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都可以被释放。

try块的三种组合方式：

　　第一种：比较适用于有异常要处理，但是没有资源要释放的。

　　　　try{

　　　　　　可能发生异常的代码；

}catch（捕获的异常类型 变量名）{

　　　　处理异常的代码；

}

　　　第二种：比较适用于既有异常又有要释放资源的代码

　　try{

　　　　　　可能发生异常的代码；

}catch（捕获的异常类型 变量名）{

　　　　处理异常的代码；

}finally{

　　释放资源的代码；

}

第三种：比较适用于内部抛出的是运行时异常，并且有资源要被释放。

　　try{

　　　　可能发生异常的代码；

}finally{

　　　　释放资源的代码；

}　

代码示例：

public class Demo39 {
    public static void main(String[] args){

        div(4,2);

    }
    public static void div(int a,int b){
      try {


        int c = a/b;
        System.out.println("c = "+c);
    }catch (Exception e){
          System.out.println("出了除数为0的异常");
          throw e;
      }finally {
          System.out.println("资源代码可以被释放");
      }
    }
}
运行结果：

 

 finally的特别情况：