2021.07.05

内部类

package OOP.Dx10内部类;
public class Outer {
    private int id=1;
    public void out(){
        System.out.println("外部类方法");
    }
    public class Inner{
     public void in(){
         System.out.println("内部类方法");
     }
     //内部类可以获得外部类的私有属性和方法
     public void getid(){
         System.out.println(id);
     }
    }
//一个Java里可以有多个class类但是只能有一个public class类
    //写在方法里的类叫做局部类
    public void age(){
        class age{}
    }
}

package OOP.Dx10内部类;
public class O2 {
    public static void main(String[] args) {
        //new了一个新对象，但没有名字，没有名字初始化类，不用将实例保存在变量中
        new Apple().eat();
        //实现了接口的类 同样没有名字
        UserService userService = new UserService() {
            @Override
            public void hello() {
            }
        };
    }
}

class Apple {
    public void eat() {
        System.out.println("0");
    }
}
interface UserService{
    void hello();
}

异常exception和错误error

package OOP.Dx11异常;
public class D01 {
    public static void main(String[] args) {
         new D01().a();
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}
//检查性异常 程序员无法预见 通常需要测试把关
//运行时异常  编译时不知道，运行时才出现
//错误（error） 不是异常 脱离程序员控制
//Java把异常当作对象处理，并定义一个基类Java.lang.Throwable作为所有异常的超类
//在JavaAPI中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
//尽量避免错误出现

异常的捕获
异常通过try catch来捕获

package OOP.Dx11异常;
public class D02 {
    public static void main(String[] args) {
        int a=2;
        int b=0;
        try {//监控区域
            System.out.println(a/b);
        }catch (ArithmeticException c){//catch（想要捕获的异常类型）捕获异常
            System.out.println("有内鬼1");
        }catch (Exception e){
            System.out.println("有内鬼2");
        }catch (Error e){
            System.out.println("有内鬼3");
        }catch (Throwable e){
            System.out.println("有内鬼4");
        }
        finally {//处理善后工作  无论有没有异常都会走
    //快捷键 ctrl+alt+t
            /*try {
                System.out.println("都结束了");
            } catch (Exception e) {
                e.printStackTrace();//打印错误的栈信息
            } finally {
            }*/
        }
    }
    //finaly 可以不要  try和catch是固定的
    //catch 可以捕获多个异常，有多个异常时，异常类型应该从上到下由小到大的顺序排列挨个捕获
}

throw 和throws

package OOP.Dx11异常;
public class D03 {
    public static void main(String[] args) {
         try{
             new D03().test(1,0);
         }catch (ArithmeticException e){
             e.printStackTrace();
         }
    }
    //throws 方法中处理不了这个异常。在方法上抛出异常
    public void test(int a,int b)throws ArithmeticException{
        if (b==0){
            throw new ArithmeticException();//throw 主动抛出异常，一般在方法中使用
        }
    }
}

自定义异常类

package OOP.Dx11异常;
//继承Exception类 就可以自定义异常类
public class D04 extends Exception{
//传递数字>10
    private int detail;
    public D04(String message, int detail) {
        this.detail = detail;
    }
    public D04(int a) {
    }
    //异常的打印信息
    @Override
    public String toString() {
        return "D04{" +
                "detail=" + detail +
                '}';
    }
}

关于自定义异常的判断及处理And异常的总结

package OOP.Dx11异常;
public class D05 {
    static void test(int a) throws D04{
        System.out.println("传递的参数为"+a);
        if(a>10){
            throw new D04 (a);//抛出
        }
        System.out.println("keyi");
    }
    public static void main(String[] args) {
        try {
            test(12);
        } catch (D04 e) {
            //增加一些处理异常的代码块
            System.out.println("D04=>"+e);
        } finally {
        }
    }
}
//处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
//在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
//对于不确定的代码，也可以加上try-catch，处理潜在的异常
//尽量去处理异常，不要简单调用printStrackTrace（）去打印输出
//具体如何处理异常，要根据不同的业务需求和异常类型去决定
//尽量添加finally语句块去释放占用的资源