DAY 18

day18

成员内部类：

一方面，作为外部类的成员

调用外部类的结构

可以被static修饰

可以被四种不同的权限修饰

另一方面，作为一个类

类内可以定义属性、方法、构造器等

可以被final修饰，表示此类不能被继承，即不使用final，就可以被继承

可以被abstract修饰，表示类不能被实例化，即不使用abstract，就可以被实例化

package shangGuiGu.day17;



public class demo03 {
    public static void main(String[] args) {
        //创建dog实例（静态的成员内部类）
       personn.dog Dog=new personn.dog();
       Dog.show();
       //创建bird实例（非静态的成员内部类）   非静态的需要需要实例化对象
        personn p=new personn();
        personn.bird bird=p.new bird();
        bird.sing();
        System.out.println("=======");
        bird.display("c");
    }

}
class personn{
    String name="a";
    int age;
    public void eat(){
        System.out.println("eat");
    }



    //静态成员内部类
    static class dog{
String name;
int age;
public void show(){
    System.out.println("dog");

}
    }
    //非静态成员内部类
    class bird{
String name="b";
public bird(){

}
public void sing(){
    System.out.println("bird");
    personn.this.eat();//调用外部类的属性
    eat();
}
public void display(String name){
    System.out.println(name);//方法的形参
    System.out.println(this.name);//this表示display所在类的name  内部类的属性
    System.out.println(personn.this.name);//外部类的属性
}
    }
    public void method(){
        //局部内部类
        class aa{

        }
    }
    //返回一个实现了comparable接口的类的对象
    public Comparable getcomparable(){
        //创建一个实现了comparable接口的类:局部内部类
        class mycomparable implements Comparable{
            
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new mycomparable();
    }
    //局部内部类
    class bb{}
    public personn(){
        //局部内部类
        class cc{

        }
    }
}

异常

Error

OOM StackOverFlowError

Exception

空指针访问

试图读取不存在的文件

网络连接中断

数组角标越界

package shangGuiGu.day18;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;

public class demo01 {
    //***********以下是编译时异常**********
    @Test
    public void test7(){
        File file = new File("hello.txt");
        FileInputStream fis=new FileInputStream(file);
        int data=fis.read();
        while(data!=-1){
            System.out.println((char)data);
            data=fis.read();
        }
        fis.close();
    }
    
    //***********以下是运行时异常**********
    @Test
    //arithmeticexception
    public void test6(){
        int a=10;
        int b=0;
        System.out.println(a/b);
    }
    @Test
    //inputmismatchexception
    public void test5(){
        Scanner scanner=new Scanner(System.in);
        int score=scanner.nextInt();
        System.out.println(score);
        scanner.close();
    }
    @Test
    //numberformatexception
    public void test4(){
        String str="123";
        str="abc";
        int num=Integer.parseInt(str);
    }
    @Test
    //classcastexception
    public void test3(){
        Object obj=new Date();
        String str=(String)obj;
    }
    //arrayindexoutofboundsexception
    @Test
    public void test2(){
        int[] arr=new int[10];
        System.out.println(arr[10]);
        //stringoutofboundsexception
        String str="abc";
        System.out.println(str.charAt(3));
    }
    //nullpointerexception
    @Test
    public void test1()
    {
        int[] arr=null;
        System.out.println(arr[3]);

        String str="abc";
        System.out.println(str.charAt(0));
    }}

异常的处理：抓抛模型

过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出。一旦抛出对象后，其后的代码不再执行。

关于异常对象的产生：①系统自动生成的异常对象②手动的生成一个异常对象，并抛出（throw）

过程二：“抓”：异常的处理方式：①try-catch-finally ②throws

try-catch-finally

try{

//可能出现异常的代码

}catch（异常类型1 变量名1）{

//处理异常的方式1

}catch（异常类型2 变量名2）{

//处理异常的方式2

}catch（异常类型3 变量名3）{

//处理异常的方式3

}

…

finally{

//一定会执行的代码}

说明：1.finally是可选的

2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配

3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况下）。继续执行其后的代码

4.catch中的异常类型若没有子父类关系，则谁声明在上，谁声明在下无所谓。

catch中的异常类型若满足子父类关系，则要求子类一定声明在父类的上面。否则报错

5.常用的异常对象处理的方式：①String getmessage() ②printStackTrace()

6.在try结构中声明的变量，出了try结构后就不能再被调用

package shangGuiGu.day18;

import org.junit.Test;

public class demo02 {
    //nullpointerexception
    @Test
    public void test1() {
        String str = "123";
        str = "abc";
        try{
        int num = Integer.parseInt(str);
            System.out.println("hello----1");
        }catch(NumberFormatException e){
            System.out.println("do not worry");
            //String getMessage():
            System.out.println(e.getMessage());
            //printStackTrace():
            e.printStackTrace();
        }
        System.out.println("hello-----2");
    }
}

像数据库链接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放，此时的资源释放就需要声明在finally中。

try-catch-finally结构可以嵌套

package shangGuiGu.day18;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;

public class demo03 {
    @Test
    public void test2(){
        FileInputStream fis=null;
        try {
            File file = new File("hello.txt");
        fis=new FileInputStream(file);
            int data=fis.read();
            while(data!=-1){
                System.out.println((char)data);
                data=fis.read();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public void testMethod(){
        int num=method();
        System.out.println(num);
    }
    public int method(){
        try{
            int[] arr=new int[10];
            System.out.println(arr[10]);
            return 1;
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            return 2;
        }finally {
            System.out.println("执行");
        }
    }
    @Test
    public void test1(){
        try{
            int a=10;
            int b=0;
            System.out.println(a/b);
        }catch (ArithmeticException e){
            e.printStackTrace();
            int[] arr=new int[10];
            System.out.println(arr[10]);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("hei");
        }
    }
}

throws方式

throw+异常类型 写在方法的声明处，指明此方法执行时，可能会抛出的异常类型。一旦方法体执行时出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码不再执行

若父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着若子类重写的方法中有异常，必须使用try-catch-finally方式处理

执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。则建议这几个方法使用throw的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

方法重写的规则之一：

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

package shangGuiGu.day18;

import java.io.IOException;

public class demo05 {
    public static void main(String[] args) {
        demo05 test=new demo05();
        test.display(new subclass());

    }
    public void display(superclass s){
        try{
            s.method();
        }catch (IOException e){
            e.printStackTrace();
        }

}}
class superclass{
    public void method()throws IOException {

    }

    }

class subclass extends superclass{
    public void method(){

    }
}

package shangGuiGu.day18;

public class demo06 {
    public static void main(String[] args) throws Exception {
        try {
            student s=new student();
            s.regist(1001);
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}
class student{
    private int id;
    public void regist(int id) throws Exception {
        if(id>0){
            this.id=id;
        }else{
//手动抛出异常对象
           // throw new RuntimeException("illegal");
            throw new Exception("illegal");
        }
    }

    @Override
    public String toString() {
        return "student{" +
                "id=" + id +
                '}';
    }
}