13-内部类\异常

一、内部类

▪ 把一个类定义在另一个类的内部称为内部类

/*
  内部类（当作类中的一个普通成员变量，只不过此成员变量是class的类型）：
        一个java文件中可以包含多个class，但是只能有一个public class
        如果一个类定义在另一个类的内部，此时可以称之为内部类
    使用：
        创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类来进行修饰
              InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();
 * */

public class InnerClassDemo {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    class InnerClass{
        private int age;
//        static String name = "zhangsan";

        public void test(){
            System.out.println("test");
        }
    }

}

public class TestInnerClass {
    public static void main(String[] args) {
//        System.gc();
        InnerClassDemo innerClassDemo = new InnerClassDemo();
        innerClassDemo.show();
        System.out.println(innerClassDemo.getName());

        InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();
        inner.test();
    }
}

/*
    特点：
        1、内部类可以方便的访问外部类的私有属性
        2、外部类不能访问内部类的私有属性,但是如果创建了内部类的对象，此时可以在外部类中访问私有属性
        3、内部类中不能定义静态属性
        4、当内部类和外部类具有相同的私有属性的时候，在内部类中访问的时候，可以直接访问内部类的属性，
            如果需要访问外部类的属性，那么需要添加  外部类类名.this.属性。
*/

public class InnerClassDemo {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    class InnerClass{
        private int age;
//        static String name = "zhangsan";

        public void test(){
            System.out.println("test");
            System.out.println(id);
            System.out.println(name);
        }
    }

}

第4点

public class Outer {

    private String name = "zhangsan";

    class Inner{
        private String name = "lisi";

        public void show(){
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(Outer.this.name);
        }
    }

    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

如果主方法在外部类内部，则可以省略Outer

public class InnerClassDemo {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("show");
//        System.out.println(age);
        InnerClass inner = new InnerClass();
        System.out.println(inner.age);
    }

    class InnerClass{
        private int age;
//        static String name = "zhangsan";

        public void test(){
            System.out.println("test");
            System.out.println(id);
            System.out.println(name);
        }

        class InnerInner{
            private int id;
            public void print(){
                System.out.println("print");
            }
        }
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClassDemo().new InnerClass();
    }
}

/*
    分类：
        匿名内部类：当定义了一个类，实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途
               此时考虑到代码编写的简洁，可以考虑不创建具体的类，而采用new interface(){添加未实现的方法}
               就叫做匿名内部类
        静态内部类：在内部类中可以定义静态内部类，使用static关键字进行修饰，使用规则
                外部类.内部类 类的引用名称 = new 外部类.内部类（）；
        方法内部类：在外部类的方法中也可以定义类，此时叫做方法内部类（了解即可）
                    使用的时候需要注意，只能在方法中创建对象，因为此class的作用域就是当前方法
*/

1、匿名内部类

public class NoNameInnerClassDemo {

    public static void main(String[] args) {
        System.out.println("有一万行代码");
        new Thread(new Runnable() { // 本质上时new了一个接口的实现类 
            // new Runner implements Runnable 把Runner implements 省略了, 就是匿名内部类
            @Override
            public void run() {

            }
        });
        System.out.println("有一万行代码");
    }


}
class Runner implements Runnable{

    @Override
    public void run() {

    }
}

2、静态内部类

public class StaticClass {

    private int id;

    public void test(){
        System.out.println("test");
    }
    static class InnerClass{
        private String name;
        public void show(){
            System.out.println("show");
        }

    }

    public static void main(String[] args) {
        InnerClass innerClass = new StaticClass.InnerClass(); // 静态属于当前类, 不用new InnerClass类了
//        InnerClass innerClass = new StaticClass().new InnerClass();

    }
}

3、方法内部类

public class MethodInnerClass {

    public void show(final int number){
        System.out.println("show");

        class InnerClass{
            private String name;
            public void test(int a){
                System.out.println("test");
                System.out.println(a);
                System.out.println(number);
            }
        }

        new InnerClass().test(12);
    }

    public static void main(String[] args) {
        MethodInnerClass  methodInnerClass = new MethodInnerClass();
        methodInnerClass.show(1234);

    }
}

▪ 注意事项：

▪ 方法内部类不能在外部类的方法以外的地方使用，

所以方法内部类不能使用访问控制符和static修饰符

二、异常

看程序：

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入被除数:");
        int num1 = in.nextInt();
        System.out.print("请输入除数:");
        int num2 = in.nextInt();
        System.out.println(String.format("%d / %d = %d",
                num1, num2, num1 / num2));
        System.out.println("前面没有出现异常");

    }
}

1、异常的概念

在程序运行过程中，出现的不正常情况叫做异常

 /*
 *       注意：
 *           1、相同的代码在运行的时候，根据输入的参数或者操作的不同，有可能会发生异常，有可能不会发生异常
 *               应该在写代码的过程中尽可能的保证代码的正确性，不要到处都bug
 *           2、如果要解决代码中出现的异常，需要添加非常复杂的代码逻辑来进行判断，会使代码变得非常臃肿，不利于维护，可读性比较差
 *               因此，推荐大家使用异常机制来处理程序运行过程中出现的问题
 *           3、程序在运行过程中如果出现了问题，会导致后面的代码无法正常执行，而使用异常机制之后，可以对异常情况进行处理
 *              同时后续的代码会继续执行，不会中断整个程序
 *           4、在异常的处理过程中，不要只是简单的输出错误，要尽可能的讲详细的异常信息进行输出
 *                  e.printStackTrace():打印异常的堆栈信息，可以从异常信息的最后一行开始追踪，寻找自己编写的java类
 */

2、异常处理（try, catch, finally, throws, throw）

 /*
 *      异常处理的方式：
 *          1、捕获异常
 *              try{代码逻辑}catch(Exception e){异常处理逻辑}
 *              try{代码逻辑}catch(具体的异常Exception e){异常处理逻辑}catch(具体的异常)：
 *                    可以针对每一种具体的异常做相应的更丰富的处理
 *                      注意：当使用多重的catch的时候一定要注意相关异常的顺序，将子类放在最前面的catch，父类放在后面的catch
 *              执行过程中可能存在的情况：
 *                  1、正常执行，只执行try中的代码
 *                  2、遇到异常情况，会处理try中异常代码之前的逻辑，后面的逻辑不会执行，最后会执行catch中的代码
 *                  3、使用多重catch的时候，会遇到异常子类不匹配的情况，此时依然会报错，因此建议在catch的最后将所有的异常的父类写上
 *InputMismatchException
 * ArithmeticException
 * */

2.1、try-catch

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("请输入被除数:");
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1 / num2));
            System.out.println("前面没有出现异常");
        }catch(Exception e){
            System.out.println("出现异常");
        }
        System.out.println("感谢使用本程序！");

    }
}

打印异常信息:

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("请输入被除数:");
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1 / num2));
            System.out.println("前面没有出现异常");
        }catch(Exception e){
            System.out.println("出现异常");
            e.printStackTrace(); // 用的多
        }
        System.out.println("感谢使用本程序！");

    }
}

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("请输入被除数:");
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1 / num2));
            System.out.println("前面没有出现异常");
        }catch(Exception e){
            //System.out.println("出现异常");
            //e.printStackTrace();
            System.out.println("--------");
            System.out.println(e.getMessage()); // 用的少
        }
        System.out.println("感谢使用本程序！");

    }
}

可以更具体的输出

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("请输入被除数:");
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1 / num2));
            System.out.println("前面没有出现异常");
//        }catch(Exception e){
////            System.out.println("出现异常");
////            e.printStackTrace();
//            System.out.println("--------");
//            System.out.println(e.getMessage());
//        }
       }catch(ArithmeticException e){
            System.out.println("数学异常，除数不能是0");
            e.printStackTrace();
        }catch (InputMismatchException e){
            System.out.println("输入的参数值类型不匹配");
            e.printStackTrace();
        }catch (NullPointerException e){
            System.out.println("空指针异常");
            e.printStackTrace();
        }
        System.out.println("感谢使用本程序！");

    }
}