内部类、异常

一、内部类

1、定义

在一个类中，定义另一个类的代码结构，通常定义在类内部的类称为“内部类”，外面的类称为“外部类”，在逻辑关系上，内部类与外部类是从属关系，比如一个People类存在收货地址类。

2、分类

2.1、 普通内部类（inner class），一个类A中定义另一个类B，其中类B就是类A的内部类，也是类A的一部分

内部类的方法可以直接访问外部类的属性（由于通常情况属性的访问必须通过对象才可以使用）

注意两点

• 外部类的方法中，可以直接访问内部类的所有成员（包括私有）

• 内部类的方法中，也可以直接方法外部类的所有成员，当外部和内部的成员名相同时，就近原则访问成员，或者引入外部类的对象访问

 

2.2、 静态内部类（static inner class）： 在普通内部类基础上，增加“static”关键字，与静态方法相似，满足静态的要求

1、对于静态方法可以直接类名.方法名

2、对于非静态方法，需要创建类的对象访问

 

2.3、方法内部类： 在一个方法中定义的类，其中这个类只属于该方法，也只能在该方法中使用

注意：内部类剩的class文件 命名 外部类$内部类名.class

 

2.4 匿名内部类： 定义一个没有类名，只有对方法的具体实现。通常它依赖于实现关系（接口）或继承关系（父类）

a、基于实现关系

public interface MyInterface {
    // 学习
    public void  study();
    //  工作
    public void work();
}


 // 创建一个匿名类(让接口的引用 指向匿名类的对象)
        MyInterface  person = new MyInterface() {
            @Override
            public void study() {
                System.out.println("这个人也好好学习");
            }

            @Override
            public void work() {
                System.out.println("这个人也好好工作");
            }
        };

        person.study();
        person.work();

b、基于继承关系

public class MyClass {

   public void service(){
        System.out.println("提供服务的方法。");
    }
}


// 父类 new 一个 匿名类，这个匿名类是它的子类
        MyClass cls = new MyClass(){
            @Override //匿名类重写父类的方法 service
            public void service() {
                System.out.println("这是子类的方法");
            }
        };
        cls.service();

二、异常

1、概述

异常定义：在程序中，发生“不正常”的事件，导致程序无法正常运行，并使JVM中断，称为异常。

捕获异常：当程序在运行时，发生了异常，为了让程序正常执行，而要对异常捕获，称之为捕获异常。

Java是面向对象的语言， 异常本身就是一个类（Exception），当发生异常时会创建异常对象，捕获的就是该对象。

2、异常关键字及层次关系

a、try： 试一试 ，将可能发生的代码使用try包裹 ，try不能单独出现

b、catch ： 捕获异常， 当发生指定的异常对象时，执行catch代码

c、 finally : 异常之后的最终处理 （无法是否发生异常，程序都执行 ）

try... catch...finally 结构

try {
            System.out.println("请输入两个数 ，计算两个数相除");
            Scanner sc = new Scanner(System.in);
            int num1 = sc.nextInt();
            int num2 = sc.nextInt();
            double s = num1 / num2; // 可能出错
            System.out.println(" try里面结束，结果：" + s);
        }catch(ArithmeticException ee){
            ee.printStackTrace();
            System.out.println("除数不能为0 ！！");
        }catch(Exception ee){
            ee.printStackTrace();
            System.out.println("系统繁忙！！！");
        }finally {
            System.out.println("用于资源回收。");
        }

3、抛出异常

  /**
     * 根据下标访问数组元素
     * @param array
     * @param index
     * @return
     */
    public static int getEleByIndex(int [] array , int index){
         // 抛出异常： 可以在异常发生时 或发生之前 创建一个异常对象并抛出
        //  手动抛出一个异常  throw new 异常类([异常消息]);
        if(index <0 || index > array.length-1){
            //抛出异常
            throw new ArrayIndexOutOfBoundsException("你的下标越界了");
        }
        int n =  array[index];
        return n;
    }

public static void main(String[] args) {
          //数组
        int  [] array = {2,1,4,5};
        int index=4;
        // 定义方法访问下标的元素  此时会产生异常 并抛出给方法的调用者
        try {
            int num = getEleByIndex(array, index);
            System.out.println("访问的元素：" + num);
        }catch(ArrayIndexOutOfBoundsException ee){
            System.out.println(ee.getMessage());
        }
        System.out.println("结束。。。");

    }

4、异常分类

由于有些异常是不能直接抛出的 ，需要先声明才可以抛出，异常可以分为两大类：

1、 编译期异常（check 异常或者检查异常）：在编译期间检查异常，如果没有处理异常,则编译出错。

这里的IOException 就是 编译期异常，需要手动处理的

//创建一个文件类的对象
        File  file = new File("d:/aaa.txt");
         // 在写代码（编译之前）时 一定要处理的异常（try..catch 或者 throws），就是编译时异常 
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

2、运行期异常（runtime 异常或者运行异常）：在运行期间检查异常， 编译期可以不处理异常。

        // 在运行期间抛出异常  不需要事先处理的  NullPointException是运行异常
        String str=null;
        System.out.println(str.length());

注意： 对于抛出检查异常，需要使用throws声明，对于抛出运行时异常，必须要使用throws声明

  /**
     *   声明抛出异常语法：
     *       public ...  方法名([参数]) throws 异常类1,异常类2{
     *
     *       }
     */
    //创建文件
    public  static void createFile() throws FileNotFoundException ,IOException {
        File file = new File("d:/hello.txt");
        if(file.exists()){
             // 不能创建  ，需要提示用户  该文件存在
            throw new FileNotFoundException("这个文件已存在，不能创建");
        }else{
            //创建
            file.createNewFile();
        }
    }

面试题： 关于 finally 和 return的执行顺序问题？

回答： 当方法有返回值时，先执行fianlly，再return， 但是 finally的代码不会改变return结果

 

5、自定义异常

a、定义编译期异常类，创建一个类继承 java.lang.Exception ；

b、定义运行期异常类，创建一个类继承java.lang.RuntimeException；

案例分析：自定义异常应用

public class RegisterException  extends  Exception {
    public RegisterException(){

    }

    public RegisterException(String message){
        // 将message 赋值给父类的构造
        super(message); //  将message赋值给父类的 属性，可通过getMessage（）方法

    }
}

public class TestRegister {
     // 模拟已存在的用户
    String []  users = {"袁魏巍","王麻子","王小花"};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要注册的用户：");
        String uname = sc.next();
        TestRegister obj = new TestRegister();

        try {
            // 调用方法
            obj.checkUserName(uname);
            System.out.println("注册成功");
        } catch (RegisterException e) {
            System.out.println("注册失败");
            System.out.println(e.getMessage());
        }


    }

    /**
     * 检查用户是否存在
     * @param username
     * @return   true  表示通过
     *    异常表示不通过
     */
    public boolean  checkUserName(String username) throws RegisterException{
         // 使用foreach遍历
        /**
         *   for(数据类型 变量名  ： 数组名/集合名 ){
         *        循环中的 变量名代表的就是数组的元素
         *   }
         */
        for(String  u : users){
            // 判断u是否与 username相等 ，相等说明用户存在，需要抛出异常
            if(u.equals(username)){
                throw new RegisterException("亲，"+username+" 已存在，不能注册");
            }
        }
        return true;

    }

}