中南林业科技大学Java实验报告九：内部类和异常类

今天药忘吃喽~ 2023-09-26 16:17 93阅读 0赞

#### 文章目录 ####

*  实验9 内部类和异常类
 *   *  9.1 实验目的
     *  9.2 实验内容
     *   *  9.2.1 编写一个Java程序，定义一个外部类和一个内部类，并在外部类中访问内部类的成员变量和方法。
         *  9.2.2 车站检查危险品的设备，如果发现危险品会发出警告。编程模拟设备发现危险品的情况。

## 实验9 内部类和异常类 ##

### 9.1 实验目的 ###

1.  了解内部类的作用；
2.  掌握内部类的使用；
3.  掌握外部类和内部类的访问原则；
4.  掌握自定义异常类；
5.  掌握Java异常处理机制；

### 9.2 实验内容 ###

#### 9.2.1 编写一个Java程序，定义一个外部类和一个内部类，并在外部类中访问内部类的成员变量和方法。 ####

【前提引入-成员内部类】

*  成员内部类是定义在外部类的成员位置上，并且没有static修饰
    
        //Outer是外部类
        public class Outer{
              
            //Inner是成员内部类
            class Inner{
              
                
            }
            
        }
 *  可以直接访问外部类的所有成员，包括 private
 *  可以添加任意访问修饰符（public，protected，default默认，private），因为它的地位就是一个成员。
 *  作用域：和外部类的其他成员一样，为整个类体
 *  成员内部类访问外部类成员：直接访问
    
        public class Outer {
               
           private String name = "外部类";
            
           public class Inner{
              
               
               public void show(){
              
                   //访问的外部类成员name
                   System.out.println(name);     
               }
                
           }
           
        }
 *  外部类访问成员内部类：创建对象再访问，且可以访问成员内部类的所有成员（包括private）
    
        public class Outer {
              
        
           public class Inner{
              
               //设置为私有
                private String name = "内部类";
           }
        
           public void show(){
              
               //外部类访问内部类成员
               
               //1. 先创建内部类
               Inner inner = new Inner();
               //2. 再访问内部类成员
               System.out.println(inner.name);
           }
        }
 *  外部其他类访问成员内部类的两种方式：
    
    1.  创建外部类对象再创建成员内部类
        
            public class Outer {
                    
            
               public class Inner{
                    
            
               }
            }
            
            class MyTest{
                    
                public static void main(String[] args) {
                    
                    Outer outer = new Outer();
                    //创建内部类
                    Outer.Inner inner1 = outer.new Inner();
                    
                    //也可以合做一句来写
                    Outer.Inner inner2 = new Outer().new Inner();
            
                }
            }
    2.  在外部类中定义方法返回成员内部类实例对象
        
            public class Outer {
                    
            
               public class Inner{
                    
            
               }
            
               public Inner createInnerInstance() {
                    
                   return new Inner();
               }
            }
            
            class MyTest{
                    
                public static void main(String[] args) {
                    
                    Outer outer = new Outer();
                    Outer.Inner innerInstance1 = outer.createInnerInstance();
                    
                    //上述两句等价于：
                    Outer.Inner innerInstance2 = new Outer().createInnerInstance();
                }
            }
 *  如果外部类和内部类的成员重名时，内部类访问的话，默认遵循`就近原则`，如果想访问外部类成员，则可以使用 外部类名.this.成员 来访问外部类成员。
    
        public class Outer {
              
           private String name = "外部类";
           
           public class Inner{
              
               private String name = "成员内部类";
               public void show() {
              
                   //就近原则 -> 访问内部类，输出：成员内部类
                   System.out.println(name);
                   
                   //访问外部类成员变量name，输出：外部类
                   System.out.println(Outer.this.name);
               }
           }
        }

【核心代码】

编写 Outer 类：

public class Outer {
        
        /**
         * 成员内部类：Inner
         */
        class Inner {
        
            /**
             * 内部类的成员变量
             */
            public String name = "普通内部类";
    
            /**
             * 内部类的成员方法
             */
            public void show() {
        
                System.out.println("====调用Inner成员方法====");
            }
        }
    
        /**
         * 测试外部类调用内部类的成员变量和成员方法
         */
        public void show() {
        
            Inner inner = new Inner();
            System.out.println("调用inner成员变量：" + inner.name);
            inner.show();
        }
    
        /**
         * 主启动类
         * @param args 参数
         */
        public static void main(String[] args) {
        
            new Outer().show();
        }
    }

【运行流程】

![image-20221101180649162][]

#### 9.2.2 车站检查危险品的设备，如果发现危险品会发出警告。编程模拟设备发现危险品的情况。 ####

【前提引入-异常简单说明】

1️⃣ 什么是异常

java语言中，将程序执行中发生的不正常情况称为"异常"。

> ⚠️开发过程中的语法错误和逻辑错误不是异常

2️⃣异常分类

*  Error
    
    1.  Java虚拟机无法解决的严重问题。
    2.  如：JVM系统内部错误，资源耗尽等严重情况。
    3.  比如：`栈溢出StackOverFlowError`和`内存不足Out of Memory`。
    4.  Error是严重错误，程序会崩溃！
 *  Exception
    
    1.  其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。
    2.  例如空指针访问，试图读取不存在的文件，网络连接终端等等。
    3.  Exception分为两大类：
        
         *  `运行时异常`：程序运行时发生的异常
         *  `编译时异常`：编译时编译器检查出的异常

3️⃣ 注意事项

*  运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。
 *  对于运行时异常，可以不做处理，因为这类异常很普遍，若全部处理可能会对程序的可读性与运行效率造成影响。
 *  编译时异常，是编译器要求程序员必须处理的异常，否则javac编译无法通过。
 *  运行时异常有时候也可以作为我们的业务逻辑的一部分。

4️⃣ 常见的运行时异常

*  NullPointerException 空指针异常
    
    当应用程序试图在需要对象的地方使用null时，抛出该异常。例如：
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                //声明为null，未实例化
                String str = null;
                //调用str的toString方法，则会抛出NullPointerException异常
                System.out.println(str.toString());
            }
        }
 *  ArithmeticException 数学运算异常
    
    当出现异常的运算条件时，抛出此异常。例如：
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                // 很明显 10/0 是一个错误的数学运算，因此抛出ArithmeticException异常
                System.out.println(10/0);
            }
        }
 *  ArrayIndexOutOfBoundsException 数组下标越界异常
    
    用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。例如：
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                // arr的数组长度为3，则索引范围是 [0,2]
                int[] arr = {
              1,2,3};
                // 索引为3，不在 [0,2] 范围内，因此抛出异常ArrayIndexOutOfBoundsException
                System.out.println(arr[3]);
            }
        }
 *  ClassCastException 类型转换异常
    
    当我们用子类对象去强制转换父类对象就会报错，同样会抛出此异常。例如：
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                //所有类都默认直接或间接继承了str，Object是顶级父类
                Object object = new Object();
                //因此这是在把一个父类实例对象转为子类,会抛出异常ClassCastException
                String str = (String)object;
        
            }
        }
 *  NumberFormatException 数字格式不正确异常
    
    当应用程序试图将字符串转换成一种数值类型，但是该字符串不能转换为适当格式时，抛出该异常 --> 使用异常我们可以确保输入是满足条件的数字
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                String str = "狐狸半面添";
                //parseInt方法：试图将str转为整型
                //但很明显，我们定义的 str 无法转为整型，因此抛出异常NumberFormatException
                int num = Integer.parseInt(str);
        
            }
        }
    
    我们还可以查看一下Integer类的parseInt方法源码，看下是否当类型不符合时真的抛出此异常：
    
    > 在这段源码中应当是可以看到大量地方提到了 throw new NumberFormatException()
    
        public static int parseInt(String s, int radix) throws NumberFormatException{
              
            /*
                 * WARNING: This method may be invoked early during VM initialization
                 * before IntegerCache is initialized. Care must be taken to not use
                 * the valueOf method.
                 */
        
            if (s == null) {
              
                throw new NumberFormatException("null");
            }
        
            if (radix < Character.MIN_RADIX) {
              
                throw new NumberFormatException("radix " + radix +
                                                " less than Character.MIN_RADIX");
            }
        
            if (radix > Character.MAX_RADIX) {
              
                throw new NumberFormatException("radix " + radix +
                                                " greater than Character.MAX_RADIX");
            }
        
            int result = 0;
            boolean negative = false;
            int i = 0, len = s.length();
            int limit = -Integer.MAX_VALUE;
            int multmin;
            int digit;
        
            if (len > 0) {
              
                char firstChar = s.charAt(0);
                if (firstChar < '0') {
               // Possible leading "+" or "-"
                    if (firstChar == '-') {
              
                        negative = true;
                        limit = Integer.MIN_VALUE;
                    } else if (firstChar != '+')
                        throw NumberFormatException.forInputString(s);
        
                    if (len == 1) // Cannot have lone "+" or "-"
                        throw NumberFormatException.forInputString(s);
                    i++;
                }
                multmin = limit / radix;
                while (i < len) {
              
                    // Accumulating negatively avoids surprises near MAX_VALUE
                    digit = Character.digit(s.charAt(i++),radix);
                    if (digit < 0) {
              
                        throw NumberFormatException.forInputString(s);
                    }
                    if (result < multmin) {
              
                        throw NumberFormatException.forInputString(s);
                    }
                    result *= radix;
                    if (result < limit + digit) {
              
                        throw NumberFormatException.forInputString(s);
                    }
                    result -= digit;
                }
            } else {
              
                throw NumberFormatException.forInputString(s);
            }
            return negative ? result : -result;
        }

5️⃣ 异常处理

异常处理就是当异常发生时，对异常的处理方式。

*  try-catch-finally
    
    程序员在代码中捕获发生的异常，自行处理
    
        public class ExceptionTest {
              
        
            public static void main(String[] args) {
              
                // 很明显 10/0 是一个错误的数学运算，因此抛出ArithmeticException异常
                try {
              
                    System.out.println(10/0);
                } catch (Exception e) {
              
                    System.out.println("这里是用来捕获发生的异常");
                    //创建一个异常类，并抛出该异常给方法的调用者来处理
                    throw new RuntimeException(e);
                }finally {
              
                    System.out.println("这里通常是进行资源释放，也可以不写finally代码块");
                }
            }
        }
 *  throws
    
    将发生的异常抛出，交给调用者来处理，最顶级的处理者就是 JVM 虚拟机
    
        public class ExceptionTest {
              
        
            // throws Exception：发生异常时则抛出异常给该方法的调用者处理
            public static void main(String[] args) throws Exception {
              
                // 很明显 10/0 是一个错误的数学运算，因此抛出ArithmeticException异常
                System.out.println(10 / 0);
            }
        }

6️⃣ 自定义异常类

*  基本概念
 *  自定义异常类的步骤
    
    1.  定义一个类：必须继承 `Excpetion类` 或 `RuntimeExcpetion类`
    2.  如果继承 Exception，属于编译异常；
        
        如果继承 RuntimeException，属于运行异常。
    3.  一般情况下爱，我们自定义异常是继承 RuntimeExcpetion，即把自定义异常做成运行时异常类，好处是可以使用默认的处理机制——throws方式处理
    4.  自定义异常类一般包含两个构造方法：一个是无参的默认构造方法，另一个构造方法以字符串的形式接收一个定制的异常消息，并将该消息传递给超类的构造方法。
 *  示例演示：
    
        public class MyException extends RuntimeException{
              
            public MyException() {
              
        
            }
            public MyException(String message) {
              
                super(message);
            }
        }

【题目要求与核心代码】

1.  通过继承Exception类，编写一个DangerException类：该异常类有构造方法，该构造方法使用super调用父类构造方法，使用字符串：“属于危险品！”，对父类变量message进行初始化。
    
        /**
         * 异常类
         */
        public class DangerException extends Exception{
              
            public DangerException() {
              
                super("属于危险品！");
            }
        }
2.  编写商品类：Goods，该类包含以下成员：
    
     *  私有的name属性(String类型)，表示商品名称。
     *  私有的isDanger属性(boolean型)，表示商品是否为危险品，如果为危险品，则值为true，否则为fales。
     *  分别为两个私有变量编写set和get方法
    
        /**
         * 商品类
         */
        public class Goods {
              
            /**
             * 商品名称
             */
            private String name;
            /**
             * 表示该商品是否为危险品，默认初始化为 false
             * true：为危险品
             * false：不是危险品
             */
            private boolean isDanger;
        
            public Goods(String name){
              
                this.name = name;
            }
        
            public String getName() {
              
                return name;
            }
        
            public void setName(String name) {
              
                this.name = name;
            }
        
            public boolean isDanger() {
              
                return isDanger;
            }
        
            public void setDanger(boolean danger) {
              
                isDanger = danger;
            }
        }
3.  编写一个Machine类，该类的方法checkBag(Goods goods)。当发现参数goods是危险品时，即：goods的isDanger属性为true时，该方法抛出DangerException异常的对象。
    
        import java.util.ArrayList;
        import java.util.Arrays;
        
        /**
         * 定义工具类，扫描是否为危险品
         */
        public class Machine {
              
            /**
             * 危险商品名集合
             */
            public final static ArrayList<String> DangerGoods = new ArrayList<String>(Arrays.asList("炸药","硫酸","硫磺"));
        
            /**
             * 检查商品是否为危险品
             *
             * @param goods 检查的商品
             */
            public static void checkBag(Goods goods) throws DangerException {
              
                if(DangerGoods.contains(goods.getName())){
              
                    throw new DangerException();
                }
            }
        }
4.  编写主类Check，在其main方法中创建创建商品对象，并使用Machine对象检查商品。
    
        /**
         * 主类：进行检查
         */
        public class Check {
              
            public static void main(String args[]) {
              
                //商品名称
                String[] name = {
              "苹果", "炸药", "西服", "硫酸", "手表", "硫磺"};
        
                Goods[] goods = new Goods[name.length];
        
                //创建商品对象
                for (int i = 0; i < name.length; i++) {
              
                    goods[i] = new Goods(name[i]);
                }
                //检查商品
                for (int i = 0; i < name.length; i++) {
              
                    try {
              
                        Machine.checkBag(goods[i]);
                        System.out.println(goods[i].getName() + "，检查通过");
                    } catch (DangerException e) {
              
                        System.out.println(goods[i].getName() + e.getMessage());
                        System.out.println(goods[i].getName() + "，被禁止！");
                    }
                    //换行分割
                    System.out.println();
                }
        
            }
        }
5.  程序输出如下：
    
        苹果，检查通过
        
        炸药属于危险品!
        炸药，被禁止!
        
        西服，检查通过
        
        硫酸属于危险品!
        硫酸，被禁止!
        
        手表，检查通过
        
        硫磺属于危险品!
        硫磺，被禁止!

【运行流程】

![image-20221101193208763][]

[image-20221101180649162]: https://img-blog.csdnimg.cn/img_convert/4a98628894e2171d2ea971516e3f0f95.png
[image-20221101193208763]: https://img-blog.csdnimg.cn/img_convert/133228e1f1c1c6758da3b1922376962a.png