一文简述JAVA内部类和异常

内部类和异常

内部类

在一个类的内部定义的一个类,例如,A类中定义了一个B类,则B类相对于A类就是内部类,而A类相对于B类就是外部类

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类

成员内部类

public class outer {
    private int ID;
    public void out(){
        System.out.println("外部类方法");
    }
    public class inner{
        public void in(){
            System.out.println("内部类方法");
        }
        public void getId(){
            System.out.println(ID);    //内部类可以获得外部类的私有属性,但是外部类使用内部类要借助内部类的对象
        }
    }
}

这就是一个类中定义一个内部类,可以通过实例化这个外部类来实例化内部类

outer o = new outer();
outer.inner o2 = o.new inner();
o2.in();
o2.getId();

静态内部类

上述inner类的定义中直接改为 public static inner即为静态内部类,静态内部类无法访问外部非静态属性(static会先加载)

一个java类中可以有多个class类,但是这个public class之外不能再写public class

public void method(){
    class inner1{
        //局部内部类
        public void in(){
            
        }
    }
}

匿名内部类(甚至匿名内部接口)

public class internalClass {
    public static void main(String[] args) {
        outer o = new outer();
        outer.inner o2 = o.new inner();
        o2.in();

        new Apple().show();
        UserService use = new UserService(){
            @Override
            public void hello(){
                System.out.println("hello");
            }
        };
    }
}


class Apple{
    public void show(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

这些都是非常见的用法,记录下来,这样用方便在于可以直接调用匿名内部类的方法

异常

异常和中断等具体将会写在”操作系统部分“

一般需要掌握以下三种类型的异常:

  • 检查型异常:最具代表性的是用户错误或问题引起的异常,例如打开一个不存在的文件等
  • 运行时异常:该类异常可能会在编译时被忽略
  • 错误ERROR:错误不是异常,是脱离程序员控制的问题,例如:栈溢出等等

java.lang.Throwable为所有异常的超类

异常总的分为两大类:错误Error和异常Exception

Error类对象由JVM生成并抛出,大多数错误与代码编写者执行的操作无关。当运行错误时,JVM不再有继续操作所需要的内存资源,将会发生OutOfMemoryError,这些异常发生时,JVM一般会选择终止线程;

Error是程序无法控制和处理的,而Exception通常情况下是可以被程序处理的

捕获和抛出异常

简单地说,异常总是先被抛出,后被捕捉的。

异常处理5个关键字:try, catch, finally, throw, throws

int a = 1;
int b = 0;

//try 监控区域
try{
    System.out.println(a/b);
}catch (ArithmeticException e ){    //捕获异常,若栈溢出的话,该类异常捕获不到,类型不同
    System.out.println("发生异常,变量b不能为0");
}finally {    //一般处理善后工作
    System.exit(0);
}

//finally可以不要,但是在IO中,有些资源需要关闭,一般可以放在finally中处理

以上为捕获异常的一个例子,若ArithmeticException e改为Throwable e,则均可被捕获。可写多个catch,相当于多个if进行判断,catch中所写的异常类型要从小到大来捕获,否则会报错

选中sout(a/b); IDEA中 ctrl+alt+T 可自动补写 try catch finally等

try {
    System.out.println(a/b);
} catch (Exception e) {
    e.printStackTrace();  //打印错误的栈信息
} finally {
}

以上为IDEA自动补写部分

主动抛出异常,用到throw,一般在方法中使用

public static void main(String[] args) {
    int a = 1;
    int b = 0;
    new exceptiondemo2().test(1,0);
}

public void test(int a,int b){
    if(b==0){
            throw new ArithmeticException();
        }
}

方法上主动抛出异常,则用throws

public void test(int a,int b)throws ArithmeticException{
    
}

自定义异常类可写一个类继承于Exception,可重写打印信息方法.toString

public void doA(int a) throws Exception1,Exception3{......}

throws E1,E2,E3只是告诉程序这个方法可能会抛出这些异常,方法的调用者可能要处理这些异常,而这些异常E1,E2,E3可能是该方法产生的。throws只是告知该方法可能会产生的异常,而throw则会在具体语句抛出异常

void doA(int a) throws Exception1,Exception2,Exception3{
           try{
                 ......

           }catch(Exception1 e){
              throw e;
           }catch(Exception2 e){
              System.out.println("出错了!");
           }
           if(a!=b)
              throw new  Exception3("自定义异常");
}

该段共可能出现3种异常,E1出现时,先catch后throw,而E2出现时只进行了捕获,后续没有抛出E2,if为自定义的判断。

throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常。

以上仅为内部类和异常的知识总结,不够详细,未涉及的部分可能会在未来补充。

posted @ 2021-03-30 23:05  GaoYuan206  阅读(66)  评论(0编辑  收藏  举报