内部类和异常

内部类

局部内部类有两种：分别是局部类()和匿名局部类

内部类有两种: 正常内部类和静态内部类

1. 四个内部类的名字

正常内部类：OuterClass$InnerClass.class

public class OuterClass {
    class InnerClass{
    }
}

静态内部类: OuterClass$InnerClass.class ,和正常内部类的名字是一样的

public class OuterClass {
    static class InnerClass{
    }
}

局部内部类：OuterClass$1InnerClass.class,和正常内部类的名字比多了一个数字1

public class OuterClass {
    public void test(){
        class InnerClass{
        }
    }
}

匿名内部类: OuterClass$1.class,跟正常内部类相比就是在外部类后面添加了一个数字

public class OuterClass {   
    public static void main(String[] args) {
        InterfaceForInnerClass inf = new InterfaceForInnerClass(){
            @Override
            public void run() {
                System.out.println("我是匿名内部类的实现");
            }
        };
    }
}

2. 内部类的理解

某种意义上来讲，内部类可以看成是类里面的一个成员变量或者局部变量

类型	内部变量和方法的特性
正常内部类	可以有四种访问修饰符修饰的变量和方法，不能有静态的变量和方法
静态内部类	可以有四种访问修饰符修饰的变量和方法，并且可以有静态的变量和方法
局部内部类	可以有四种访问修饰符修饰的变量和方法，不能有静态的变量和方法
匿名内部类	直接实现父类定义的方法，一般不做其他的操作

对于上面这四种类型的类而言，它们的创建对象的条件也不尽相同 ：

1. 正常内部类需要实例化对象的话必须要先实例化外部类对象

2. 静态内部类对象可以直接实例化

3. 局部内部类只能在被声明的方法里面被实例化

另外！！！还有内部类和外部类属性重名的情况：

普通内部类的情况：遇到同名的情况优先使用内部类的，创建外部类对象调用new Car().color

public class Car {
    String color = "绿色的";
    private void run(){
        System.out.println("跑");
    }  
    public class 发动机{
        String  color = "红色的";
        String type;
        public void work(){
            System.out.println("发动机");
            run();
            System.out.println(new Car().color);// 内部类属性和外部类属性同名的时候, 优先使用内部类的 ,
            //即使用this也是使用的内部类的, 除非创建外部类对象调用
        }
    }
}

局部内部类的情况: 遇到同名的情况也是优先使用内部类的,使用外部类.this.属性 调用外部类的属性

public class Car {
    String  color = "绿色的";

    private  void run(){
        System.out.println("跑");
    }
    public  class 发动机{
        String  color = "红色的";
        String type;
        
        public void test(){
            public void work(){
                System.out.println("发动机");
                run();//内部类是可以使用外部类的属性和方法的, 包括私有的
               // 如果局部内部类中的属性和外部类成员属性同名, 则可以使用外部类.this.属性 调用外部类的属性
                System.out.println(Test.this.a);
            }
        }
 }

Java中的异常

异常就是有异于常态，和正常情况不一样，有错误出现

异常的分类:

Throwable
    |
    |-- Error
    |-- Exception
    	|--RuntineException
    	|--CheckedException

Error: 程序中无法处理的错误，表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题，比如常见的OOM,SOF

Exception：程序本身可以捕获并且可以处理的异常

• 运行时异常(不受检异常)：RuntimeException类极其子类表示JVM在运行期间可能出现的错误。编译器不会检查此类异常，并且不要求处理异常，比如用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理
• 非运行时异常(受检异常)：Exception中除RuntimeException极其子类之外的异常。编译器会检查此类异常，如果程序中出现此类异常，比如说IOException，必须对该异常进行处理，要么使用try-catch捕获，要么使用throws语句抛出，否则编译不通过

异常的处理

1. 直接抛出，交给调用方处理

   public class ExceptionTest {
       
       public static void test() throws Exception {
           throw new Exception("我要抛异常");
       }
   	//这里对异常不进行处理，直接抛出，如果出错了，没路可走
       public static void main(String[] args) throws Exception {
           test();
       }
   }
   

2. 不抛出，自己处理

   public class ExceptionTest {
   	//throw关键字声明抛出异常
       public static void test() throws Exception {
           throw new Exception("我要抛异常");
       }
   
       public static void main(String[] args){
           try {
               test();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
   

自定义异常：继承RuntimeException类

public class MyException extends RuntimeException {
    public MyException(String msg){
        super(msg);
    }
    public void test(int a){
        if(a < 0){
            throw new MyException("输入值不能为负数");
        }
    }
}

异常的执行顺序解析

 try {
            String s = null;
            int i = 1/0; //这一步的异常破获后就不会往下执行,直接进catch块
            s.length();
        } catch (ArithmeticException e) { //e = new ArithmeticException(); //父类实现
            System.out.println("数字异常");
        }catch (NullPointerException e){
            System.out.println("空指真异常");
        }catch (Exception e){ //父类必须放在子类的下面,因为直接定义在上面就不走子类的分支了
            System.out.println("父类异常");
        }
        System.out.println("异常搞完了");