Java基础09：内部类；异常；final；

关键字：内部类；异常；final；

一、内部类

    1、将一个类定义在另一个类的里面，对里面那个类就成为 内部类（内置类，嵌套类）
    2、访问特点、访问规则：
        (1)、 内部类可以直接访问外部类中的成员，包括私有成员
        (2)、 而外部类要访问内部类中的成员必须要建立内部类的对象
        (3)、之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用， 格式类名.this
        (3)、 外部类.内部类 变量名 = new 外部类().new 内部类();
二、静态内部类
    1、当内部类在成员位置上时，就可以被成员修饰符所修饰
        (1)、private：将内部类在外部类中进行封装
        (2)、static：内部类就具备了静态的特性，当内部类别static修饰后，只能直接访问外部类中的static成员，出现了访问局限
        (3)、访问被static 修饰的内部类，访问非静态    new 外部类.内部类().方法
        (3)、访问被static 修饰的内部类，访问静态    new 外部类.内部类.方法
    2、访问格式
        (1)、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象
        (2)、外部类.内部类 变量名 = new 外部类().new 内部类();
    3、主意：
        (1)、 当内部类中定义了静态成员，该内部类必须是static
        (2)、当外部类中的静态方法，访问内部类时，内部类也必须是 static
三、内部类定义原则  
    1、类是用来描述事物的，当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。
    2、隐藏内部类，提供相应接口
    3、内部类定义在局部，时
        (1)、不可以被成员修饰符修饰

        (2)、可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部的变量，只能访问被final修饰的局部变量。

四、匿名内部类    
    1、匿名内部类其实就是内不累的简写形式
    2、定义匿名内部类的前提
        (1)、内部类必须是继承一个类或者实现接口

    3、例子

    4、匿名内部类的格式：new 父类或者接口(){定义子类的内容}

    5、其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，也可以理解为，带内容的对象
    6、例子

    abstract class  AbsDemo{
        abstract void show();
    }
    class Outer{
        int x = 3;
        void method(){
            System.out.println("outer:"+x);
        }
        public void function(){
            new AbsDemo(){
                void show(){
                    System.out.println("x="+x);
                }
            }.show();
        }
    }
    public class Demo{  
        public static void main(String[] args){  
            new Outer().function();
        }  
    }

    7、匿名颞部类中定义的方法最好不要超过3个
    8、例子
 

   // abstract class Inter{
        // void method();
    // }
    interface Inter{
        void method();
    }
    class Test{
        // static class Inner implements Inter{
            // public void method(){
                // System.out.println("method run");
            // }
        // }
        static Inter function(){
            //return new Inner();
            return new Inter(){
                public void method(){
                    System.out.println("mehthod run");
                }
            };
        }
    }
    public class Demo{  
        public static void main(String[] args){  
            Test.function().method();
        }  
    }

五、异常
    1、异常的体系
        (1)、error
            通常出现重大问题如：运行的类不存在或者内存溢出等
            不缩写针对代码对其处理
        (2)、exception
            在运行是运行出现的一起情况，都可以通过 try catch finally
    2、exception和error的子类都是以父类名作为后缀
    3、异常：就是程序在运行时出现不正常情况
    4、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述，后的对象体系那。
    5、对于问题的划分：两种
        (1)、一种是严重的问题，java通过error类进行描述
            a、对于error，一般不编写针对性的代码对其进行处理
        (2)、对于非严重的，java通过exception类进行描述
            b、对于exception可以使用针对想的
        (3)、无论error或者exception都具有一些共性内容，比如：不正常情况的信息，引发原因等。
    6、Throwable
        (1)、Error
        (2)、Exception
    7、例子

    class ExceptionDemo{  
        int div(int a,int b){
            return a/b;
        }
    }
    public class Demo{  
        public static void main(String[] args){  
            ExceptionDemo ed = new ExceptionDemo();
            int x = ed.div(4,0);
            //x = ed.div(4,1);//编译不报错，但是运行报错    Exception in thread "main" java.lang.ArithmeticException: / by zero    at ExceptionDemo.div(Demo.java:3)    at Demo.main(Demo.java:9)
            System.out.println("x="+x);
            System.out.println("over");
        }
    }

六、异常try-catch
    1、异常的处理
        try{
            需要被检测的代码
        }catch(){
            处理异常的代码：（处理方式）
        }finally{
            一定会执行的语句
        }
    2、例子

class ExceptionDemo{  
    int div(int a,int b){
        return a/b;        //产生了 ArithmeticException，并把问题封装成了一个对象
    }
}
public class Demo{  
    public static void main(String[] args){  
        ExceptionDemo ed = new ExceptionDemo();
        try{
            int x = ed.div(4,0);        //new ArithmeticException()
            System.out.println("x="+x);    //因为上边已经发生了异常，所以这一步不会再执行
        }catch(Exception e){            //Exception e = ArithmeticException();
            System.out.println("除零了");
            System.out.println(e.toString());//异常名称：异常信息
            System.out.println(e.getMessage());//by zero
            System.out.println(e.printStackTrace());//异常名称，异常信息，异常出现的位置
                                                    //其实jvm默认的异常处理机制，就是在调用printStackTrace方法。打印异常的堆栈的跟踪信息。
        }
        System.out.println("over");
    }
}

    3、对捕获到的异常进行常见方法操作。
        (1)、String getMessage()：获取异常信息
        (2)、toString():返回此 throwable 的简短描述
七、异常声明throws
    1、在类的函数上 声明  throws Exception，在对象在调用函数时，必须捕捉或者声明抛出
    2、声明异常时，建议声明更具体的异常，这样处理可以更具体
    3、对方声明几个异常，就对应有几个catch块
        (1)、如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
    4、建立在进行catch处理是，catch中一定要定义具体处理方式，不要简单定义一句，e.printStackTrace(),也不要简单的就书写出一条语句
    5、

class ExceptionDemo{  
    int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{    //再功能上通过 throws 的关键字声明了该功能有可能会出现问题,可以声明多个异常
        int[] arr = new int[a];
        System.out.println(arr[3]);//虽然有多个异常，但是当前面有异常时，该方法块内，异常后面的就不会运行
        return a/b;        
    }
}
public class Demo{  
    public static void main(String[] args){  
        ExceptionDemo ed = new ExceptionDemo();
        try{
            int x = ed.div(3,0);        
            System.out.println("x="+x);
        }catch(ArithmeticException e){
            System.out.println("除零了");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("角标越界了");
        }
        System.out.println("over");
    }
}

八、自定义异常    
    1、因为项目中会出现特有的问题，而这些问题并未被java所表述并封装对象，所以对于这些特有的问题可以按照java的对问题的封装思想。将特有的问题，进行自定义的异常封装
    2、当在函数内部出现了 throw 抛出异常对象，那么就必须要给对应的处理动作
        (1)、要么在内部 try catch 处理，
        (2)、要么在函数上声明让调用者处理
    3、一般情况下，函数内出现异常，函数上需要声明
    4、定义异常信息，因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过 getMessage 方法获取自定义的异常信息
    5、自定义类必须是继承 Exception 类。
    6、为什么要继承exception
        (1)、异常体系有一个特点：因为异常类和异常对象都要被抛出，他们都具备可抛性
        (2)、这个可抛性是 Throwable 这个体系中独有特点
        (3)、只有这个体系中的类和对象才可以被 throws 和 throw 操作
    7、例子
/*
需求：在本程序中，对于除数是-1，也视为是错误

*/
class FuShuException extends Exception{
    private int value;
    FuShuException(String msg,int value){
        super(msg);//定义异常信息，因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过 getMessage 方法获取自定义的异常信息
        this.value = value;
    }
    public int getValue(){
        return value;
    }
}
class ExceptionDemo{
    int div(int a,int b) throws FuShuException{    //函数内出现异常，函数上需要声明
        if(b<0){
            throw new FuShuException("除数为负数了",b);
        }
        return a/b;        
    }
}
public class Demo{
    public static void main(String[] args){  
        ExceptionDemo ed = new ExceptionDemo();
        int x = 0;
        try{
            x = ed.div(3,-1);    
        }catch(FuShuException e){
            System.out.println(e.toString());
            System.out.println("该负数是："+e.getValue());
        }
        System.out.println("x="+x);
        System.out.println("结束");
    }
}

十、throw和throws的区别
    1、throws 使用在函数上，throw 使用在函数内
    2、throws 后面跟的异常类，可以跟多个，用逗号隔开，throw 后面跟的是异常对象。
十一、RuntimeException
    1、Exception中有一个特殊的子类异常， RuntimeException 运行异常
    2、如果在函数内抛出异常，函数上可以不用声明，编译一样通过
    3、如果在函数上声明了该异常，调用者可以不用进行处理。编译一样通过
    4、之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止，因为在运行时，出现了无法继续的运算情况，希望停止程序后，对代码进行修正。
    5、自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承 RuntimeException
    6、对于异常，分两种
        (1)、编译时被检测的异常（如Exception）
        (2)、编译时不被检测的异常（运行时异常，RuntimeException以及子类）