Java基础知识（十）匿名内部类&异常基础

今天药忘吃喽~ 2022-02-25 04:06 166阅读 0赞

匿名内部类是内部类的一种简写形式，不写名字而已。  
使用有个前提是：匿名内部类必须是继承一个类或者实现接口。  
格式： new 父类()\{里面重写要写的方法\}.方法();

事实上，方法前面的一堆相当于是一个子类对象。

通常，匿名内部类中定义的方法最好不要超过3个。因为匿名内部类就是为了简化代码而已，它把1复写父类2建立对象3调用方法 放在一起写了。所以方法一定要少，一般不多于3个。

最常见使用内部类的情况是：需要传一个方法少于三个的接口作为参数时。举例如下：

show(new Inner()  
\{  
public void balabala()  
\{  
Sys("");  
\}  
\});  
\*/

abstract class Abs
    {
        abstract void method();
    }
    
    class Outer
    {
        int x = 3;
    
        /*
        class Inner extends Abs
        {
            void method()
            {
                System.out.println("method:"+x);
            }
    
        }
        */
        public void fun()
        {
           // new Inner().method();
           new Abs()       //匿名内部类
           {
                void method()
                {
                     System.out.println("method:"+x);
                }
           }.method();
        }
    }
    class AbsDemo
    {
        public static void main(String[] args)
        {
            new Outer().fun();
        }
    }

还可以这样写：

public void fun()
        {
           // new Inner().method();
           Abs in = new Abs()
           {
                void method()
                {
                     System.out.println("method:"+x);
                }
                void print()
                {
                    System.out.println("i am a little tired ");
                }
           }
            in.method();
            in.print();   //前提是父类中也有这个方法。若没有刚不能这样调用。
        }

下面讲的是异常。

异常：程序在运行时出现的不正常情况。  
异常也是一种生活中存在的事物，也被描述成了类并封装成对象。  
其实就是把一些常见问题封装成了对象，叫异常。  
分成两种，严重的一种封装成Error类，不严重的封装成Exception类  
对error一般不写针对性代码对其处理。  
对exception一般有针对性代码对其处理。  
把error和exception向上抽取出共性的东西组成了异常的超类 throwable  
偷师：java中为了提高可读性把父类名字写成子类名的后缀，这点很好，比如xxError一看就知道是Error类的子类。  
格式：  
try\{  
要被检测的代码  
\}  
catch(异常类 变量)\{ 处理方法\}  
finally\{一定会执行的语句\}

常用对捕获的异常进行的操作：  
1 getMessage()  
2 printStackTrace()  
3 toString()

throws Exception的含意：抛给虚拟机

对多异常的处理：  
1、抛出异常时建议声明为更具体的异常，这样方便处理。比如throws AtithmeticException,ArrayIndexOutOfBoundsException  
但此时需要用两个catch去处理。发生哪个异常哪个catch去处理，但只会有一个catch被执行。  
2、如果声明的几个异常出现继承关系，父类异常放最下面。  
3、不要定义多余的catch块。  
4、catch中要有具体的解决方法，或者形成异常日志文件。

class Demo
    {
        int div(int a,int b)throws Exception //在功能上通过关键字声明出该功能可能会出现问题。
        {
            return a/b;
        }
    }
    class ExDemo
    {
        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(e.getMessage());
                System.out.println(e.toString());  //异常信息：异常名称
                e.printStackTrace();//异常名称：异常信息，异常出现的位置。（JVM默认异常处理就是它。）
            }
    
            System.out.println("over");
        }
    
    }

自定义异常：一些我们项目中特有的而java没有封装的异常。必须是继承自Exception否则没用。

继承的原因：异常类和异常对象都需要被抛出因为它们会导致跳转，它们都具备可抛性，这个可抛性只有throwable类的独有特点，  
只有这个体系中的成员才能被throw和throws这两个关键字操作。

throws 和 throw 区别：  
1、throws 使用位置在函数上（小括号和大括号之间），throw在函数内  
2、throws 后面跟的是异常类，可以跟多个，用逗号隔开。throw 后面跟异常对象。

需求：在本程序中除数不可以为负数。

当函数内部已经出现异常，则必须有解决，常用方法有两种：1在内部try catch处理 2在函数上声明，让调用者处理。

自定义的异常如何定义所属信息？（重写父类中的getMessage方法）  
因为父类中都写完了，子类只需要在构造时将异常信息传递给父类，通过super语句，那么就可以通过getMessage方法获取自定义的异常信息了。

所有的函数内抛都必须在函数上声明，一个真香特例是runtimeException可以不这样做。  
RunTimeException: 如果在函数内容出现异常，函数上可以不用声明，编译一样通过。  
如果在函数上声明异常，调用者可以不用处理，编译一样通过。

class FuShuException extends Exception  //定义异常类，注意起名时候后面有后缀（好习惯）
    {
        /*
        private String msg;
    
        FuShuException(String msg)
        {
            this.msg = msg;
        }
        public String getMessage()
        {
            return msg;
        }*/
    
        private int key;
    
        FuShuException(String msg,int key)
        {
            super(msg);
            this.key = key;
        }
        public int getKey()
        {
            return key;
        }
    }
    class Demo
    {
        int div(int a,int b )throws FuShuException
        {
            if(b<0)     //注意下面的throw没有s
                throw new FuShuException("被除数小于零了呀！",b);  //手动通过建立对象抛出自定义异常。
            return a/b;
        }
    
    }
    class Test
    {
        public static void main(String[] args)
        {
            Demo d = new Demo();
    
            try
            {   int x = d.div(4,-1);
    
                System.out.println("x="+x);
            }
    
            catch(FuShuException e)
            {
                System.out.println(e.toString());
                System.out.println("the wrong number is "+e.getKey());
            }
            System.out.println("over");
        }
    }