java数组异常类型总结及用法

  • 时间:
  • 2226人关注

在本篇文章里小编给各位分享的是一篇关于java数组中的异常类型整理内容,有兴趣的朋友们可以学习下。,另外这篇文章主要知识点是关于java数组、异常类型、java异常类的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子资料:

教程详情电子资料
  • 教程类别:java异常类
  • 编辑整理:怀思凡
  • 教程字数:1215字节
  • 阅读时间:大概6分钟
  • 下载本教程(DOC版)
  • java基础知识笔记
  • Java jdk14 API官方帮助文档
  • Java并发编程的艺术
  • 软件项目开发全程实录:Java项目开发全程实录(第3版)
  • Java线程与并发编程实践
  • 对于程序中出现异常,是很多程序员不想看到的情况,因为这就需要我们去查询异常的原因,然后进行一些处理异常的操作。在Java数组操作时,也会有一些异常情况的发生。这里我们罗列出了两种:ClassCastException和NullPointerException,下面我们来看一下具体的介绍。

    1、异常种类

    检查型异常和非检查型异常的主要区别在于其处理方式。检查型异常都需要使用try,catch 和finally 关键字在编译器进行处理,否则会出现编译器报错。对于非检查型异常则不需要这样做。Java中所有继承 Exception 的类的异常都是检查型异常,所有继承RuntimeException 的异常都被称为非检查型异常。

    2、ClassCastException

    类转换异常,将一个不是该类的实例转换成这个类就会抛出这个异常。

    如将一个数字强制转换成字符串就会报这个异常:

    Object x = new Integer(0);
    System.out.println((String)x);

    这是运行时异常,不需要手工捕获。

    3、空指针异常NullPointerException

    操作一个 null 对象的方法或属性时会抛出这个异常。

    //情况一:
    int[] arr1 = new int[]{1,2,3};
    arr1 = null;
    System.out.println(arr1[0]);
    
    //情况二:
    int[][] arr2 = new int[4][];
    System.out.println(arr2[0][0]);
    
    //情况:
    String[] arr3 = new String[]{"AA","BB","CC"};
    arr3[0] = null;
    System.out.println(arr3[0].toString());

    提示:一旦程序出现异常,未处理时,就终止执行。

    内容扩展:

    • 算术异常类:ArithmeticExecption
    • 空指针异常类:NullPointerException
    • 类型强制转换异常:ClassCastException
    • 数组负下标异常:NegativeArrayException
    • 数组下标越界异常:ArrayIndexOutOfBoundsException
    • 违背安全原则异常:SecturityException
    • 文件已结束异常:EOFException
    • 文件未找到异常:FileNotFoundException
    • 字符串转换为数字异常:NumberFormatException
    • 操作数据库异常:SQLException
    • 输入输出异常:IOException
    • 方法未找到异常:NoSuchMethodException

    到此这篇关于java数组中的异常类型整理的文章就介绍到这了,更多相关java数组中的异常有哪些内容请搜索码农之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持码农之家!

    码农之家
    Java内部类和异常类的概念以及使用

    22小时59分钟前回答

    Java内部类和异常类的概念以及使用

    1 内部类

    Java支持在一个类中声明另一个类,这样的类称作内部类,而包含内部类的类成为内部类的外嵌类。

    内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员。

    内部类的使用规则:
    (1)声明内部类如同在类中声明方法或变量一样,一个类把内部类看作是自己的成员。
    (2)外嵌类的类体中可以用内部类声明的对象,作为外嵌类的成员。
    (3)外嵌类的成员变量在内部类中仍然有效,内部类中的方法也可以调用外嵌类中的方法。
    (4)内部类的类体中不可以声明类变量和方法。
    (5)外嵌类和内部类在编译时,生成两个.class文件。

    例如:某种类型的农场饲养了一种特殊种类的牛,但不希望其他农场饲养这种特殊种类的牛,那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。
    下面的例子1(Example1.1.java)中有一个RedCowForm(红牛农场)类,该类中有一个名字为RedCow (红牛)的内部类。

    RedCowForm.java

    public class RedCowForm {
        static String formName;
        RedCow cow;  //内部类声明对象
    
        RedCowForm() {
        }
    
        RedCowForm(String s) {
            cow = new RedCow(150, 112, 5000);
            formName = s;
        }
    
        public void showCowMess() {
            cow.speak();
        }
    
        class RedCow {  //内部类的声明
            String cowName = "红牛";
            int height, weight, price;
    
            RedCow(int h, int w, int p) {
                height = h;
                weight = w;
                price = p;
            }
    
            void speak() {
                System.out.println("偶是" + cowName + ",身高:" + height + "cm 体重:" + weight + "kg,生活在" + formName);
            }
        }    //内部类结束
    }
    115526523

    Example1.1.java

    public class Example1_1 {
        public static void main(String[] args) {
            RedCowForm form = new RedCowForm("红牛农场");
            form.showCowMess();
            form.cow.speak();
        }
    }
    

    需要特别注意的是,Java编译器生成的内部类的字节码文件的名字和通常的类不同,内部类对应的字节码文件的名字格式是“外嵌类名$ 内部类名”,例如,例子1中内部类的字节码文件是RedCowForm$RedCow.class。因此,当需要把字节码文件复制给其他开发人员时,不要忘记了内部类的字节码文件。
    内部类可以被修饰为static 内部类,例如,例子1中的内部类声明可以是static classRedCow。类是一种数据类型,那么static内部类就是外嵌类中的一-种静 态数据类型,这样一来,程序就可以在其他类中使用static内部类来创建对象了。但需要注意的是,static 内部类不能操作外嵌类中的实例成员变量。

    假如将例子1中的内部类RedCow更改成static内部类,就可以在例子1的Example1_ 1
    主类的main方法中增加如下的代码。

    RedCowForm.RedCow redCow = new RedCowForm.RedCow(180,119,6000);
            redCow.speak();

    注意:非内部类不可以是static类

    2 匿名类

    2.1 和子类有关的匿名类

    创建子类对象时,除了使用父类的构造方法外还有类体,此类体被认为是一个子类去掉类声明后的类体,称作匿名类。

    假设Bank是类,那么下列代码就是用Bank的一个子类(匿名类)创建对象:

    new Bank() {
    	匿名类的类体
    };

    和子类有关的匿名类:
    (1)匿名类是一个子类,由于无名可用,所以不可能用匿名类声明对象,但却可以直接用匿名类创建一个对象。
    (2)匿名类可以继承父类的方法也可以重写父类的方法。
    (3)使用匿名类时,必然是在某个类中直接用匿名类创建对象,以此,匿名类一定是内部类。
    (4)匿名类可以访问外嵌类中的成员变量和方法,匿名类的类体中不可以声明static成员变量和static方法。
    (5)由于匿名类是一个子类,但没有类名,所以在用匿名类创建对象时,要直接使用父类的构造方法。

    例子2:该类共有4个类: (Example2_1. java)、ShowBoard类、
    OutputAlphabet类型、 OutputEnglish. java 。该匿名类的对象负责输出希腊字母表。

    OutputAlphabet.java

    abstract class OutputAlphabet {
        public abstract void output();
    }

    OutputAlphabet .java

    public class OutputEnglish extends OutputAlphabet { //输出英文字母子类
        public void output(){
            for (char c='a';c<='z';c++){
                System.out.printf("%3c",c);
            }
        }
    }
    

    ShowBoard .java

    public class ShowBoard {
        void showMess(OutputAlphabet show) { //参数show是OutputAlphabet类型的对象
            show.output();
        }
    }

    Example2_1.java

    public class Example2_1 {
        public static void main(String[] args) {
            ShowBoard board = new ShowBoard();
            board.showMess(new OutputEnglish());//向参数传递OutputAlphabet的子类OutputEnglish的对象
    
            board.showMess(new OutputAlphabet() {   //向参数传递OutputAlphabet的匿名子类的对象
                @Override
                public void output() {
                    for (char c = 'α'; c <= 'ω'; c++)  //输出希腊字母
                        System.out.printf("%3c", c);
                }
            });//分号在这里
        }
    }
    

    2.2 和接口有关的匿名类

    和接口有关的匿名类
    假设Computable是一个接口,那么,Java允许直接用接口名和一个类体创建一个匿名对象,此类体被认为是实现了Computable接口的类去掉类声明后的类体,称作匿名类。

    下列代码就是用实现了Computable接口的类(匿名类)创建对象:

    new Computable(){
    	实现接口的匿名类的类体
    };

    下面例子演示了和接口有关的匿名类的用法:

    interface SpeakHello {
        void speak();
    }
    
    class HelloMachine {
        public void turnOn(SpeakHello hello) {
            hello.speak();
        }
    }
    
    public class Example7_3 {
        public static void main(String[] args) {
            HelloMachine machine = new HelloMachine();
            machine.turnOn(new SpeakHello() {
                @Override
                public void speak() {
                    System.out.println("hello,you are welcome!");
                }
            });
            machine.turnOn(new SpeakHello() {
                @Override
                public void speak() {
                    System.out.println("你好,欢迎光临!");
                }
            });
        }
    }
    

    3 异常类

    所谓异常就是程序运行时可能出现一些错误,比如试图打开一个根本不存在的文件等,异常处理将会改变程序的控制流程,让程序有机会对错误作出处理。程序运行出现异常时,Java运行环境就用异常类Exception的相应子类创建一个异常对象,并等待处理。异常对象可以调用如下方法得到或输出有关异常的信息:

    异常对象可以调用如下方法得到或输出有关异常的信息:

    public String getMessage();
    public void printStackTrace();
    public String toString();

    3.1 try-catch语句

    Java使用try-catch语句来处理异常,将可能出现的异常操作放在try-catch语句的try部分,将发生异常后的处理放在catch部分。
    try-catch语句的格式如下:

    try{
    	包含可能发生异常的语句
    }
    catch(ExceptionSubClass1 e){
    	...
    }
    catch(ExceptionSubClass2 e){
    	...
    }

    下面一个例子给出了try-catch语句的用法:

    public class Example3_1 {
        public static void main(String[] args) {
            int n = 0, m = 0, t = 1000;
    
            try {
                m = Integer.parseInt("8888");
                n = Integer.parseInt("ab89"); //发生异常,转向catch
                t = 7777;  //t没有机会被赋值
            } catch (NumberFormatException e) {
                System.out.println("发生异常:" + e.getMessage());
            }
            System.out.println("n=" + n + ",m=" + m + ",t=" + t);
    
            try {
                System.out.println("故意抛出I/O异常!");
                throw new java.io.IOException("我是故意的");
                //System.out.println("这个输出语句肯定没有机会执行,所以必须注释掉,否则编译出错");
            } catch (java.io.IOException e) {
                System.out.println("发生异常:" + e.getMessage());
            }
        }
    }
    

    带finally子语句的try~catch语句,语法格式如下:

    try{ }
    catch(ExceptionSubClass e){ }
    finally{}

    其执行机制是在执行try~catch语句后,执行finally 子语句,也就是说,无论在try部分是否发生过异常,finally 子语句都会被执行

    3.2 自定义异常类

    (1)一个方法不处理它产生的异常,而是沿着调用层次向上传递,由调用它的方法来处理这些异常,叫声明异常.

    声明异常的方法:
    在产生异常的方法名后面加上要抛出(throws)的异常的列表:

    如: void compute(int x) throwsAri thmeticException
    {//这里有异常发生,但是并没有处理…}

    (2)我们也可以扩展Exception类定义自己的异常类,然后规定哪些方法产生这样的异常。一个方法在声明时可以使用throws关键字声明要产生的若干个异常,并在该方法的方法体中具体给出产生异常的操
    作,即用相应的异常类创建对象,并使用throw关键字抛出该异常对象,导致该方法结束执行。

    (3)通常情况下,计算两个整数之和的方法不应当有任何异常放出,但是,对某些特殊应程序,可能不允许同号的整数做求和运算,比如当一个整数代表收入,一个整数代表支出时,这两个整数就不能是同号。

    例子 (Example3_2. java)中,Bank类中有一个income(int in, int out)方法,对象调用该方法时,必须向参数in传递正整数、向参数out传递负数,并且int+out必须大于等于0,否则该方法就抛出异常( BankException. java )。因此,Bank类在声明income(int in, int out)方法时,使用throws关键字声明要产生的异常。

    BankException.java

    public class BankException extends Exception {
        String message;
    
        public BankException(int m, int n) {
            message = "入账资金" + m + "是负数或支出" + n + "是正数,不符合系统要求.";
        }
    
        public String warnMess() {
            return message;
        }
    }
    

    Bank.java

    public class Bank {
        private int money;
    
        public void income(int in, int out) throws BankException {
            if (in <= 0 || out >= 0 || in + out <= 0) {
                throw new BankException(in, out); //方法抛出异常,导致方法结束
            }
            int netIncome = in + out;
            System.out.printf("本次计算出的纯收入是:%d元\n", netIncome);
            money = money + netIncome;
        }
    
        public int getMoney() {
            return money;
        }
    }
    

    Example3_2.java

    public class Example3_2 {
        public static void main(String[] args) {
            Bank bank = new Bank();
            try {
                bank.income(200, -100);
                bank.income(300, -100);
                bank.income(400, -100);
                System.out.printf("银行目前有%d元\n", bank.getMoney());
                bank.income(200, 100);
                bank.income(99999, -100);
            } catch (BankException e) {
                System.out.println("计算收益的过程出现如下问题:");
                System.out.println(e.warnMess());
            }
            System.out.printf("银行目前有%d元\n", bank.getMoney());
        }
    }
    

    4 断言

    断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用,这样就可以发现一些致命的错误,当程序正式运行时就可以关闭断言语句,但仍把断言语句保留在源代码中,如果以后应用程又需要调试,可以重新启用断言语句。

    使用关键字assert声明一条断言语句,断言语句有以下两种格式:

    assert booleanExpression;

    assert booleanExpression:messagelException;

    启用与关闭断言语句
    当使用Java解释器直接运行应用程序时,默认地关闭断言语句,在调试程序时可以使用-ea启用断言语句,例如:
    java -ea mainClass

    例子4中,使用一个数组放着某学生5门课程的成绩,程序准备计算学生的成绩的总和。在调试程序时使用了断言语句,如果发现成绩有负数,程序立刻结束执行。程序调试开启断言语句运行效果如图4.1,关闭断言语句运行效果如图4.2。

    import java.util.Scanner;
    public class Example4 {
      public static void main (String args[ ]) {
           int [] score={-120,98,89,120,99};
           int sum=0;
           for(int number:score) {
              assert number>0:"负数不能是成绩";
              sum=sum+number;
           } 
           System.out.println("总成绩:"+sum);    
       }
    }
    

    图4.1

    图4.2

    5 综合案例

    下面的例子5中模拟向货船上装载集装箱,如果货船超重,那么货船认为这是一个异常将拒绝装载集装箱,但无论是否发生异常,货船都需要正点启航

    DangerException.java

    public class DangerException extends Exception {
        final String message = "超重";
        public String warnMess() {
            return message;
        }
    }
    

    CargoBoat.java

    public class CargoBoat {
        int realContent;  //装载的重量
        int maxContent;   //最大装载量
        public void setMaxContent(int c) {
            maxContent = c;
        }
        public void loading(int m) throws DangerException {
            realContent += m;
            if(realContent>maxContent) {
                throw new DangerException();
            }
            System.out.println("目前装载了"+realContent+"吨货物");
        }
    }
    

    Example5.java

    public class Example5 {
        public static void main(String[] args) {
            CargoBoat ship = new CargoBoat();
            ship.setMaxContent(1000);
            int m =600;
            try{
                ship.loading(m);
                m = 400;
                ship.loading(m);
                m = 367;
                ship.loading(m);
                m = 555;
                ship.loading(m);
            }
            catch(DangerException e) {
                System.out.println(e.warnMess());
                System.out.println("无法再装载重量是"+m+"吨的集装箱");
            }
            finally {
                System.out.printf("货船将正点启航");
            }
        }
    }
    

    到此这篇关于Java内部类和异常类的概念以及使用的文章就介绍到这了,更多相关java类的使用内容请搜索码农之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持码农之家!

    展开阅读

    上一篇:JAVA快速搭建基本的springboot

    下一篇:Java下奇怪的Base64知识点详解

    相关内容

    • Java中常见异常打印输出方式

      Java异常是在Java应用中的警报器,下面这篇文章主要给大家介绍了关于Java中异常打印输出的常见方法的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面来一起看看

      01-09Java中异常打印输出的常见方法总结

      阅读更多
    • java自定义异常实例详解

      这篇文章主要为大家详细介绍了java简单自定义异常实例代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

      11-04java简单自定义异常实例代码

      阅读更多
    • Java异常区分和处理的经验方法总结

      这篇文章介绍了Java异常区分和处理的一些经验分享,主要是异常选择和使用中的一些误区总结与归纳,具有一定参考价值,需要的朋友可以了解下。

      08-29Java异常区分和处理的一些经验分享

      阅读更多
    • Java异常类型以及异常处理总结

      在本篇文章里小编给大家分享了关于Java的异常类型的相关知识点内容,有需要的朋友们跟着学习下。

      05-30Java异常类处理知识点

      阅读更多
    • javaSystem.out.println()输出byte[]、char[]异常的解决办法

      这篇文章主要给大家介绍了关于javaSystem.out.println()输出byte[]、char[]异常问题的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面

      06-17javaSystem.out.println()输出byte[]、char[]异常的问题详析

      阅读更多
    • java异常与处理机制分析

      这篇文章主要介绍了java的异常与处理机制,结合实例形式分析了Java异常与处理机制的概念、原理、相关操作技巧与注意事项,并附带面试题分析供大家参考,需要的朋友可以参考下

      08-11java的异常与处理机制分析【附面试题】

      阅读更多
    • JavaWeb开发实战1200例(第2卷)

      JavaWeb开发实战1200例(第2卷)

      大小:63 MBJavaWeb

      点击下载
    • 《Java编程技术大全》视频教学录像

      《Java编程技术大全》视频教学录像

      内容介绍 本书主要面向零基础读者,用实例引导读者学习,深入浅出地介绍Java的相关知识和实战技能。 本书第Ⅰ篇基础知识主要讲解Java开发环境搭建、Java程序要素,并逐一介绍常量、变量、运算符、表达式、语句、流程控制、数组、枚举、类、对象以及方法等; 第Ⅱ篇核心技术主要介绍类的封装、继承、多态,并逐一介绍抽象类、接口、Java常用类库以及异常的捕获与处理等; 第Ⅲ篇*级应用主要介绍多线程、文件I/O操作、GUI编程、Swing GUI编程、Jav

      大小:3.2 GBJava

      点击下载
    • Java语言程序设计题解与上机指导

      Java语言程序设计题解与上机指导

      Java语言程序设计题解与上机指导 作者:邵丽萍,郭春芳,张后扬编著 清华大学 ISBN:7302101698/9787302101697 出版时间:2005-01-01 丛编项:高等院校计算机应用技术规划教材

      大小:14.92MBJava

      点击下载
    • 深入解析Java虚拟机HotSpot

      深入解析Java虚拟机HotSpot

      编辑推荐 (1)作者是阿里云Java技术专家,热衷于研究编程语言的设计与实现,对Java虚拟机和编译器都有较深入的研究。 (2)深入分析HotSpot VM的核心源码,全面解析运行时、垃圾回收器、即时编译器的实现原理和工作机制 (3)详细描述虚拟机底层实现,同时与上层Java应用和库相结合,为JVM的开发、调优和排错指明方向 内容简介 很多JVM的底层技术细节你是否只了解表面? 面对JVM Crash或性能调优方面的问题时你是否会束手无策? 面对上层Java应用发生

      大小:149 MBJava虚拟机

      点击下载
    • 阿里巴巴Java开发手册

      阿里巴巴Java开发手册

      这本书愿景是码出高效,码出质量,提炼阿里巴巴集团技术团队的集体编程经验和软件设计智慧,浓缩成为立体的编程规范和实践,适合计算机相关行业的管理者和研发人员、高等院校的计算机专业师生、求职者等阅读

      大小:27.5 MBJava开发

      点击下载

    学习笔记

    32小时10分钟前回答

    Java内部类和异常类的概念以及使用

    1 内部类 Java支持在一个类中声明另一个类,这样的类称作内部类,而包含内部类的类成为内部类的外嵌类。 内部类的类体中不可以声明 类变量和类方法。外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员。 内部类的使用规则: (1)声明内部类如同在类中声明方法或变量一样,一个类把内部类看作是自己的成员。 (2)外嵌类的类体中可以用内部类声明的对象,作为外嵌类的成员。 (3)外嵌类的成员变量在内部类中仍然有效,内部类中的方法也可以调用外嵌类中的方法。 (4)内部类的类体中不可以声明类变量和方法。 (5)外嵌类和内部类在编译时,生成两个.class文件。 例如:某种类型的农……

    6小时33分钟前回答

    Java异常类型以及异常处理总结

    1002 Java的异常类型总结 Java的设计目的是让程序员有机会设计一个没有错误的应用程序。当应用程序与资源或用户交互时,程序员可能会知道一些异常,这些异常是可以处理的。不幸的是,也有程序员无法控制或简单忽略的例外情况。简而言之,并不是所有的异常都是相同的,因此程序员需要考虑几种类型。 异常是导致程序无法在其预期的执行中运行的事件。异常有三种类型检查异常、错误和运行时异常。 The Checked Exception(检查异常) 已检查异常是Java应用程序应该能够处理的异常。例如,如果应用程序从文件中读取数据,它应该能够处理FileNotFoundException。毕竟,无法保证预期的文件会出现在它应该出……