day09内部类 异常

内部类：当描述事物时，事物的内部类还有事务，该事物用内部类来描述。

内部类的访问规则:
1,内部类可以直接访问外部类中的成员，包括私有，。
  之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2,外部类要访问内部类，必须建立内部类对象。

访问格式：
1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，
可以直接建立内部类对象。
格式：
    外部类名.内部类名 对象 = 外部类对象.内部类对象
    outer.inner in = new outer().new inner();
2，当内部类在成员位置上，就可以被成员修饰符所修饰、
    比如 private： 将内部类在外部类中进行封装
      static：内部类就具备static的特性。
    当内部类被static 修饰后，只能直接访问外部类中的static成员。出现了访问局限
    
    在外部类其他类中，如何直接访问static内部类的非静态成员呢
      new outer.inner().function();

    在外部其他类中，如何直接访问static内部类的静态成员呢
    outer.inner.function();

   注意：当内部类中定义了静态成员，该内部类必须是static的、、
    当外部类中的静态方法访问内部类时，内部类也必须是static。

class outer
{
    int x=3;
    
    static class inter
    {
        static void function()
        {
            System.out.println("inner ;"+outer.this.x);
        }
    }
    void method()
    {
        inter in = new inter;
        in.function();
    }
}


class test 
{
    public static void main(String[] args)
    {
        outer out = new outer();
        out.method();
        //直接访问内部类中的成员；
        //outer.inner in = new outer().new inner();
        //in.function();
    }
}

 内部类定义在局部变量时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用
    但是不可以访问他所在的局部中的变量。只能访问被final修饰的局部变量。

class outer
{
    int x=3;
    
    
    void method()
    {
        final int x=34;
        class inter
        {    
             void function()
            {
                System.out.println("inner ;"+x);
            }
        new inner().function();
        }
    }
}

匿名内部类；
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提
内部类必须是继承一个类或者实现一个接口
3，匿名内部类的格式： new 父类或者接口（）{定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象

abstract class AbsDemo
{
    abstract void show();
}

class outer
{
    int x=2;
    
    /*
    class inner extends AbsDemo 
    {
        void show()
        {
            System.out.println("show :"+x);
        }
    }
    */
    
    public void function()
    {
        //new inner().show();
        
        new AbsDemo()//匿名类  
        {
            void show()
            {        
                System.out.println("show  :"+x);
            }
        }.show();
    }
}

异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象
其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分：两种：一种是严重的问题，一种非严重的问题、

对于严重的，java通过error类进行描述。
对于error一般不编写针对性的代码对其进行处理

对于非严重的，java通过exception类进行描述
对于exception可以通过针对性的处理方式进行处理。

无论error后者exception都具有一些共性内容。
比如不正常情况的信息，引发原因等。

Throwable
|--Error

|--Exception

2异常的处理

java提高了特有的语句进行处理。
try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常代码：（处理方式）
}
finally
{
一定会执行的语句
}

class Demo
{
    int div(int a,int b)
    {
        return a/b;
    }
}

class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);
        }
        catch(Exception e)
        {    
            System.out.println("除零了");
        }
        System.out.println("over");
    }
}

 对于多异常的处理:
1，声明异常时，建议声明更为具体的异常，这样处理可以更为具体
2，对方声明几个异常，就对应几个catch快
    如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

class Demo
{
    int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
    {
        int[] arr = new int[a];
        System.out.println(arr[4]);
        return a/b;
    }
}
class ExceptionDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,0);
            System.out.println("x="+x);
        }
        
        catch(ArithmeticException e)
        {    
            System.out.println(e.toString());
        }
        catch(ArrayIndexOutOfBoundsException e)
        {    
            System.out.println(e.toString());
        }
        catch(Exception e)
        {    
            System.out.println(e.toString());
        }
        System.out.println("over");
    }
}

 自定义异常；

如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，将异常信息传递给父类通过super语句，
那么就可以直接通过getMessage方法获取自定义异常信息。

自定义异常：
必须是自定义类继承Exception。

/*
需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义描述、

当在函数内部出现throw抛出异常对象，那么就必须要给对应的处理动作，
要么在内部try catch处理。
要么在函数上声明让调用者处理。

一般情况在，函数内出现异常，函数上需要声明。
*/
class fushuException extends Exception
{
    fushuException()
    {
        super();
    }    
    
    fushuException(String msg)
    {
        super(msg);
    }
}


class Demo
{
    int div(int a,int b)throws fushuException
    {
        if(b<0)
        throw new fushuException("dd");//手动通过throw关键字抛出一个自定义异常对象。
        return a/b;
    }
}

class test
{
     public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int x = d.div(4,-3);
            System.out.println("x="+x);
        }

 继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出、
他们都具备可抛性，这个可泡性是Throwable这个体系中情有独钟的特点。

只有这个体系中的类和对象才可以被throws和throw操作。

throw和throws的区别：
1，throws使用在函数上。 throw使用在函数内。
2，throws后面跟的异常类，可以跟多个，用逗号隔开。
throw 后跟的是异常对象。



Excepion 中有一个特殊的子类异常RuntimeException运行时异常。

如果函数内容抛出异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过、

之所以不用再函数声明，是因为不需要让调用者处理，
当该异常发生，希望程序停止。因为在运行是，除了无法继续运算的清空，希望停止程序后，
对代码进行修改

自定义异常时：如果该异常的发生，无法再继续进行运算，
就让自定义异常继承RuntimeException。

对于异常分两种：
1，编译时被检测的异常。

2，编译时不被检测的异常（运行时异常。RuntimeException以及其子类）

finally代码块：定义一定执行的代码。
主要释放资源。
异常在子类覆盖中的体现：
1，子类再覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类或者不抛。
2，如果父类方法抛出多个异常，那么子类在覆盖该方法是，只能抛出父类异常的子集。
3，如果父类或者接口的方法中没有异常抛出，那么子类再覆盖方法是，也不可以抛出异常。
    如果子类方法发生异常。就必须要进行try处理，绝对不能抛。