java异常学习案例_java异常案例 - CSDN
  • Java学习过程中,我们会碰到各种各样的异常,现将面试过程中遇到的常见异常做一罗列并举例: 1.NullPointerException: 空指针异常。菜鸟编程经验发现这个异常是经常会发生的,属于运行时异常。 举例: ...

    在Java学习过程中,我们会碰到各种各样的异常,现将面试过程中遇到的常见异常做一罗列并举例:


    1.NullPointerException: 空指针异常。菜鸟编程经验发现这个异常是经常会发生的,属于运行时异常。

    举例:

    public static void main(String[] args) {
    String str = null;
    //此处报空指针异常
    System.out.println(str.length());
    }

    控制台输出的异常信息为:

    Exception in thread "main" java.lang.NullPointerException
    at cn.com.gjw.MyClass.main(MyClass.java:7)


    2.ClassCastException: 类型强制转换异常。Java的一些语法知识不太熟悉的时候会发生的异常。

    举例:

    public static void main(String[] args) {
    // 类型强制转换异常
    Object x = new String("String");
    System.out.println((Integer) x);
    }

    控制台输出的异常信息为:

    Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at cn.com.gjw.MyClass.main(MyClass.java:7)


    3.ArrayIndexOutOfBoundsException: 数组下标越界异常。特别常见的一个异常,粗心的程序员都会犯的错误。

    举例:

    public static void main(String[] args) {
    int arr[] = {1,2};
    // 此处报数组下标越界异常
    System.out.println(arr[2]);
    }

    控制台输出的异常信息为:

    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at cn.com.gjw.MyClass.main(MyClass.java:7)


    4.ArithmeticException:算术运算异常。算术跟我水平差不多的你有没有犯过类似的错误呢??

    举例:

    public static void main(String[] args) {
    // 整数0做了分母,报算术运算异常
    System.out.println(1 / 0);
    }

    控制台输出的异常信息为:

    Exception in thread "main" java.lang.ArithmeticException: / by zero
    at cn.com.gjw.MyClass.main(MyClass.java:6)


    5.NumberFormatException: 数字格式异常。什么是数字格式异常呢?一个例子说明一切。

    举例:

    public static void main(String[] args) {
    // 将字符串“it”转换为Integer类型的,当然会报数字格式异常啦
    System.out.println(Integer.parseInt("it"));
    }

    控制台输出的异常信息为:

    Exception in thread "main" java.lang.NumberFormatException: For input string: "it"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:492)
    at java.lang.Integer.parseInt(Integer.java:527)
    at cn.com.gjw.MyClass.main(MyClass.java:6)


    以上是Java中常见的五种异常及相应的例子,Java中还有很多类似的异常等着我们去发现,这只是冰山一角中的一点。。。





    展开全文
  • 想要很好的运用异常光靠系统自带的异常体系是不够的,这时候我们就需要自定义异常,自定义异常是一定要继承异常体系的(Exception编译异常和runtimeException运行时异常),只有这样才能被throw和throws关键字操作。...
    
    

    想要很好的运用异常光靠系统自带的异常体系是不够的,这时候我们就需要自定义异常,自定义异常是一定要继承异常体系的(Exception编译异常runtimeException运行时异常),只有这样才能被throw和throws关键字操作。一起来看案例里吧。

    java学习11天-自定义异常&异常转换(实例应用)

    源代码如下,需要的收藏吧:

    //异常转换实际应用

    class NoPlanException extends Exception

    {

    NoPlanException(String msg)

    {

    super(msg);

    }

    }

    class LanPingException extends Exception

    {

    LanPingException(String msg)

    {

    super(msg);

    }

    }

    class MaoYanException extends Exception

    {

    MaoYanException(String msg)

    {

    super(msg);

    }

    }

    class Computer

    {

    private int state=2;//电脑运行状态标识:0:正常 1:蓝屏 2:冒烟

    public void run()throws LanPingException,MaoYanException

    {

    if (state==1)

    {

    throw new LanPingException("蓝屏啦。。");

    }

    if (state==2)

    {

    throw new MaoYanException("冒烟啦。。");

    }

    System.out.println("电脑运行中。。");

    }

    public void reset()

    {

    state=0;

    System.out.println("电脑重启了");

    }

    }

    class Teacher

    {

    private String name;

    private Computer comp;

    Teacher(String name)

    {

    this.name=name;

    comp=new Computer();

    }

    public void prelect()throws NoPlanException

    {

    try

    {

    comp.run();

    }

    catch (LanPingException e)

    {

    System.out.println(e.toString());

    comp.reset();

    prelect();

    }

    catch (MaoYanException e)

    {

    System.out.println(e.toString());

    test();

    throw new NoPlanException(name+":没法儿工作了");

    }

    }

    public void test()

    {

    System.out.println("做练习吧!");

    }

    public String getName()

    {

    return name;

    }

    }

    public class Exceptiontest

    {

    public static void main(String[] args)

    {

    Teacher t=new Teacher("滑稽老师");

    try

    {

    t.prelect();

    System.out.println(t.getName()+"正在讲课中。。");

    }

    catch (NoPlanException e)

    {

    System.out.println(e.toString());

    System.out.println("换人吧。");

    }

    }

    }

    运行结果(运行状态依次为:0、1、2):

    java学习11天-自定义异常&异常转换(实例应用)

    喜欢我的记得订阅哦,持续更新ing。。。

    欢迎一起讨论java知识。

    展开全文
  • java之八 异常处理

    2018-05-31 20:45:33
    Java异常是一个描述在代码段中发生的异常(也就是出错)情况的对象。当异常情况发生,一个代表该异常的对象被创建并且在导致该错误的方法中被引发(throw)。该方法可以选择自己处理异常或传递该异常。两种情况下,...

     

     

     

     

     

     

     

     

     

     

    异常处理基础

     

     

    视频课堂:https://edu.csdn.net/course/play/8222

    Java异常是一个描述在代码段中发生的异常(也就是出错)情况的对象。当异常情况发生,一个代表该异常的对象被创建并且在导致该错误的方法中被引发(throw)。该方法可以选择自己处理异常或传递该异常。两种情况下,该异常被捕获(catch)并处理。异常可能是由Java运行时系统产生,或者是由你的手工代码产生。被Java引发的异常与违反语言规范或超出Java执行环境限制的基本错误有关。手工编码产生的异常基本上用于报告方法调用程序的出错状况。

    Java异常处理通过5个关键字控制:try、catch、throw、throws和finally。下面讲述它们如何工作的。程序声明了你想要的异常监控包含在一个try块中。如果在try块中发生异常,它被抛出。你的代码可以捕捉这个异常(用catch)并且用某种合理的方法处理该异常。系统产生的异常被Java运行时系统自动引发。手动引发一个异常,用关键字throw。任何被引发方法的异常都必须通过throws子句定义。任何在方法返回前绝对被执行的代码被放置在finally块中。

    下面是一个异常处理块的通常形式:

    try{

    //blockofcodetomonitorforerrors

    }

    catch(ExceptionType1exOb){

    //exceptionhandlerforExceptionType1

    }

    catch(ExceptionType2exOb){

    //exceptionhandlerforExceptionType2

    }

    //...

    finally{

    //blockofcodetobeexecutedbeforetryblockends

    }

    这里,ExceptionType是发生异常的类型。下面将介绍怎样应用这个框架。

    异常类型

     

     

    所有异常类型都是内置类Throwable的子类。因此,Throwable在异常类层次结构的顶层。紧接着Throwable下面的是两个把异常分成两个不同分支的子类。一个分支是Exception。该类用于用户程序可能捕捉的异常情况。它也是你可以用来创建你自己用户异常类型子类的类。

    在Exception分支中有一个重要子类RuntimeException。该类型的异常自动为你所编写的程序定义并且包括被零除和非法数组索引这样的错误。另一类分支由Error作为顶层,Error定义了在通常环境下不希望被程序捕获的异常。Error类型的异常用于Java运行时系统来显示与运行时系统本身有关的错误。堆栈溢出是这种错误的一例。本章将不讨论关于Error类型的异常处理,因为它们通常是灾难性的致命错误,不是你的程序可以控制的。

    未被捕获的异常

     

     

    在你学习在程序中处理异常之前,看一看如果你不处理它们会有什么情况发生是很有好处的。下面的小程序包括一个故意导致被零除错误的表达式。

    classExc0{

    publicstaticvoidmain(Stringargs[]){

    intd=0;

    inta=42/d;

    }

    }

    当Java运行时系统检查到被零除的情况,它构造一个新的异常对象然后引发该异常。这导致Exc0的执行停止,因为一旦一个异常被引发,它必须被一个异常处理程序捕获并且被立即处理。该例中,我们没有提供任何我们自己的异常处理程序,所以异常被Java运行时系统的默认处理程序捕获。任何不是被你程序捕获的异常最终都会被该默认处理程序处理。默认处理程序显示一个描述异常的字符串,打印异常发生处的堆栈轨迹并且终止程序。下面是由标准javaJDK运行时解释器执行该程序所产生的输出:

    java.lang.ArithmeticException:/byzero

    atExc0.main(Exc0.java:4)

    注意,类名Exc0,方法名main,文件名Exc0.java和行数4是怎样被包括在一个简单的堆栈使用轨迹中的。还有,注意引发的异常类型是Exception的一个名为ArithmeticException的子类,该子类更明确的描述了何种类型的错误方法。本章后面部分将讨论,Java提供多个内置的与可能产生的不同种类运行时错误相匹配的异常类型。

    堆栈轨迹将显示导致错误产生的方法调用序列。例如,下面是前面程序的另一个版本,它介绍了相同的错误,但是错误是在main()方法之外的另一个方法中产生的:

    classExc1{

    staticvoidsubroutine(){

    intd=0;

    inta=10/d;

    }

    publicstaticvoidmain(Stringargs[]){

    Exc1.subroutine();

    }

    }

    默认异常处理器的堆栈轨迹结果表明了整个调用栈是怎样显示的:

    java.lang.ArithmeticException:/byzero

    atExc1.subroutine(Exc1.java:4)

    atExc1.main(Exc1.java:7)

    如你所见,栈底是main的第7行,该行调用了subroutine()方法。该方法在第4行导致了异常。调用堆栈对于调试来说是很重要的,因为它查明了导致错误的精确的步骤。

     

    使用try和catch

     

     

    尽管由Java运行时系统提供的默认异常处理程序对于调试是很有用的,但通常你希望自己处理异常。这样做有两个好处。第一,它允许你修正错误。第二,它防止程序自动终止。大多数用户对于在程序终止运行和在无论何时错误发生都会打印堆栈轨迹感到很烦恼(至少可以这么说)。幸运的是,这很容易避免。

    为防止和处理一个运行时错误,只需要把你所要监控的代码放进一个try块就可以了。紧跟着try块的,包括一个说明你希望捕获的错误类型的catch子句。完成这个任务很简单,下面的程序包含一个处理因为被零除而产生的ArithmeticException异常的try块和一个catch子句。

    classExc2{

    publicstaticvoidmain(Stringargs[]){

    intd,a;

    try{//monitorablockofcode.

    d=0;

    a=42/d;

    System.out.println("Thiswillnotbeprinted.");

    }catch(ArithmeticExceptione){//catchdivide-by-zeroerror

    System.out.println("Divisionbyzero.");

    }

    System.out.println("Aftercatchstatement.");

    }

    }

    该程序输出如下:

    Divisionbyzero.

    Aftercatchstatement.

    注意在try块中的对println()的调用是永远不会执行的。一旦异常被引发,程序控制由try块转到catch块。执行永远不会从catch块“返回”到try块。因此,“Thiswillnotbeprinted。”将不会被显示。一旦执行了catch语句,程序控制从整个try/catch机制的下面一行继续。

    一个try和它的catch语句形成了一个单元。catch子句的范围限制于try语句前面所定义的语句。一个catch语句不能捕获另一个try声明所引发的异常(除非是嵌套的try语句情况)。

    被try保护的语句声明必须在一个大括号之内(也就是说,它们必须在一个块中)。你不能单独使用try。构造catch子句的目的是解决异常情况并且像错误没有发生一样继续运行。例如,下面的程序中,每一个for循环的反复得到两个随机整数。这两个整数分别被对方除,结果用来除12345。最后的结果存在a中。如果一个除法操作导致被零除错误,它将被捕获,a的值设为零,程序继续运行。

    //Handleanexceptionandmoveon.

    importjava.util.Random;

     

    classHandleError{

    publicstaticvoidmain(Stringargs[]){

    inta=0,b=0,c=0;

    Randomr=newRandom();

     

    for(inti=0;i<32000;i++){

    try{

    b=r.nextInt();

    c=r.nextInt();

    a=12345/(b/c);

    }catch(ArithmeticExceptione){

    System.out.println("Divisionbyzero.");

    a=0;//setatozeroandcontinue

    }

    System.out.println("a:"+a);

    }

    }

    }

     

    显示一个异常的描述

     

    Throwable重载toString()方法(由Object定义),所以它返回一个包含异常描述的字符串。你可以通过在println()中传给异常一个参数来显示该异常的描述。例如,前面程序的catch块可以被重写成

    catch(ArithmeticExceptione){

    System.out.println("Exception:"+e);

    a=0;//setatozeroandcontinue

    }

    当这个版本代替原程序中的版本,程序在标准javaJDK解释器下运行,每一个被零除错误显示下面的消息:

    Exception:java.lang.ArithmeticException:/byzero

    尽管在上下文中没有特殊的值,显示一个异常描述的能力在其他情况下是很有价值的——特别是当你对异常进行实验和调试时。

    使用多重catch语句

     

     

    某些情况,由单个代码段可能引起多个异常。处理这种情况,你可以定义两个或更多的catch子句,每个子句捕获一种类型的异常。当异常被引发时,每一个catch子句被依次检查,第一个匹配异常类型的子句执行。当一个catch语句执行以后,其他的子句被旁路,执行从try/catch块以后的代码开始继续。下面的例子设计了两种不同的异常类型:

    //Demonstratemultiplecatchstatements.

    classMultiCatch{

    publicstaticvoidmain(Stringargs[]){

    try{

    inta=args.length;

    System.out.println("a="+a);

    intb=42/a;

    intc[]={1};

    c[42]=99;

    }catch(ArithmeticExceptione){

    System.out.println("Divideby0:"+e);

    }catch(ArrayIndexOutOfBoundsExceptione){

    System.out.println("Arrayindexoob:"+e);

    }

    System.out.println("Aftertry/catchblocks.");

    }

    }

    该程序在没有命令行参数的起始条件下运行导致被零除异常,因为a为0。如果你提供一个命令行参数,它将幸免于难,把a设成大于零的数值。但是它将导致ArrayIndexOutOfBoundsException异常,因为整型数组c的长度为1,而程序试图给c[42]赋值。

    下面是运行在两种不同情况下程序的输出:

    C:\>javaMultiCatch

    a=0

    Divideby0:java.lang.ArithmeticException:/byzero

    Aftertry/catchblocks.

    C:\>javaMultiCatchTestArg

    a=1

    Arrayindexoob:java.lang.ArrayIndexOutOfBoundsException

    Aftertry/catchblocks.

    当你用多catch语句时,记住异常子类必须在它们任何父类之前使用是很重要的。这是因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。这样,如果子类在父类后面,子类将永远不会到达。而且,Java中不能到达的代码是一个错误。例如,考虑下面的程序:

    /*Thisprogramcontainsanerror.

     

    Asubclassmustcomebeforeitssuperclassinaseriesofcatchstatements.Ifnot,

    unreachablecodewillbecreatedanda

    compile-timeerrorwillresult.

    */

    classSuperSubCatch{

    publicstaticvoidmain(Stringargs[]){

    try{

    inta=0;

    intb=42/a;

    }catch(Exceptione){

    System.out.println("GenericExceptioncatch.");

    }

    /*Thiscatchisneverreachedbecause

    ArithmeticExceptionisasubclassofException.*/

    catch(ArithmeticExceptione){//ERROR-unreachable

    System.out.println("Thisisneverreached.");

    }

    }

    }

    如果你试着编译该程序,你会收到一个错误消息,该错误消息说明第二个catch语句不会到达,因为该异常已经被捕获。因为ArithmeticException是Exception的子类,第一个catch语句将处理所有的面向Exception的错误,包括ArithmeticException。这意味着第二个catch语句永远不会执行。为修改程序,颠倒两个catch语句的次序。

    嵌套try语句

     

     

    Try语句可以被嵌套。也就是说,一个try语句可以在另一个try块内部。每次进入try语句,异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊异常的catch处理程序,堆栈将弹出,下一个try语句的catch处理程序将检查是否与之匹配。这个过程将继续直到一个catch语句匹配成功,或者是直到所有的嵌套try语句被检查耗尽。如果没有catch语句匹配,Java的运行时系统将处理这个异常。下面是运用嵌套try语句的一个例子:

    //Anexampleofnestedtrystatements.

    classNestTry{

    publicstaticvoidmain(Stringargs[]){

    try{

    inta=args.length;

     

    /*Ifnocommand-lineargsarepresent,

    thefollowingstatementwillgenerate

    adivide-by-zeroexception.*/

    intb=42/a;

     

    System.out.println("a="+a);

     

    try{//nestedtryblock

    /*Ifonecommand-lineargisused,

    thenadivide-by-zeroexception

    willbegeneratedbythefollowingcode.*/

    if(a==1)a=a/(a-a);//divisionbyzero

     

    /*Iftwocommand-lineargsareused,

    thengenerateanout-of-boundsexception.*/

    if(a==2){

    intc[]={1};

    c[42]=99;//generateanout-of-boundsexception

    }

    }catch(ArrayIndexOutOfBoundsExceptione){

    System.out.println("Arrayindexout-of-bounds:"+e);

    }

     

    }catch(ArithmeticExceptione){

    System.out.println("Divideby0:"+e);

    }

    }

    }

    如你所见,该程序在一个try块中嵌套了另一个try块。程序工作如下:当你在没有命令行参数的情况下执行该程序,外面的try块将产生一个被零除的异常。程序在有一个命令行参数条件下执行,由嵌套的try块产生一个被零除的错误。因为内部的块不匹配这个异常,它将把异常传给外部的try块,在那里异常被处理。如果你在具有两个命令行参数的条件下执行该程序,由内部try块产生一个数组边界异常。下面的结果阐述了每一种情况:

    C:\>javaNestTry

    Divideby0:java.lang.ArithmeticException:/byzero

    C:\>javaNestTryOne

    a=1

    Divideby0:java.lang.ArithmeticException:/byzero

    C:\>javaNestTryOneTwo

    a=2

    Arrayindexout-of-bounds:java.lang.ArrayIndexOutOfBoundsException

    当有方法调用时,try语句的嵌套可以很隐蔽的发生。例如,你可以把对方法的调用放在一个try块中。在该方法内部,有另一个try语句。这种情况下,方法内部的try仍然是嵌套在外部调用该方法的try块中的。下面是前面例子的修改,嵌套的try块移到了方法nesttry()的内部:

    /*Trystatementscanbeimplicitlynestedvia

    callstomethods.*/

    classMethNestTry{

    staticvoidnesttry(inta){

    try{//nestedtryblock

    /*Ifonecommand-lineargisused,

    thenadivide-by-zeroexception

    willbegeneratedbythefollowingcode.*/

    if(a==1)a=a/(a-a);//divisionbyzero

     

    /*Iftwocommand-lineargsareused,

    thengenerateanout-of-boundsexception.*/

    if(a==2){

    intc[]={1};

    c[42]=99;//generateanout-of-boundsexception

    }

    }catch(ArrayIndexOutOfBoundsExceptione){

    System.out.println("Arrayindexout-of-bounds:"+e);

    }

    }

     

    publicstaticvoidmain(Stringargs[]){

    try{

    inta=args.length;

     

    /*Ifnocommand-lineargsarepresent,

    thefollowingstatementwillgenerate

    adivide-by-zeroexception.*/

    intb=42/a;

    System.out.println("a="+a);

     

    nesttry(a);

    }catch(ArithmeticExceptione){

    System.out.println("Divideby0:"+e);

    }

    }

    }

    该程序的输出与前面的例子相同。

    引发(throw)异常

     

     

    到目前为止,你只是获取了被Java运行时系统引发的异常。然而,程序可以用throw语句引发明确的异常。Throw语句的通常形式如下:

    throwThrowableInstance;

    这里,ThrowableInstance一定是Throwable类类型或Throwable子类类型的一个对象。简单类型,例如int或char,以及非Throwable类,例如String或Object,不能用作异常。有两种可以获得Throwable对象的方法:在catch子句中使用参数或者用new操作符创建。

    程序执行在throw语句之后立即停止;后面的任何语句不被执行。最紧紧包围的try块用来检查它是否含有一个与异常类型匹配的catch语句。如果发现了匹配的块,控制转向该语句;如果没有发现,次包围的try块来检查,以此类推。如果没有发现匹配的catch块,默认异常处理程序中断程序的执行并且打印堆栈轨迹。

    下面是一个创建并引发异常的例子程序,与异常匹配的处理程序再把它引发给外层的处理程序。

    //Demonstratethrow.

    classThrowDemo{

    staticvoiddemoproc(){

    try{

    thrownewNullPointerException("demo");

    }catch(NullPointerExceptione){

    System.out.println("Caughtinsidedemoproc.");

    throwe;//rethrowtheexception

    }

    }

     

    publicstaticvoidmain(Stringargs[]){

    try{

    demoproc();

    }catch(NullPointerExceptione){

    System.out.println("Recaught:"+e);

    }

    }

    }

    该程序有两个机会处理相同的错误。首先,main()设立了一个异常关系然后调用demoproc()。demoproc()方法然后设立了另一个异常处理关系并且立即引发一个新的NullPointerException实例,NullPointerException在下一行被捕获。异常于是被再次引发。下面是输出结果:

    Caughtinsidedemoproc.

    Recaught:java.lang.NullPointerException:demo

    该程序还阐述了怎样创建Java的标准异常对象,特别注意下面这一行:

    thrownewNullPointerException("demo");

    这里,new用来构造一个NullPointerException实例。所有的Java内置的运行时异常有两个构造函数:一个没有参数,一个带有一个字符串参数。当用到第二种形式时,参数指定描述异常的字符串。如果对象用作print()或println()的参数时,该字符串被显示。这同样可以通过调用getMessage()来实现,getMessage()是由Throwable定义的。

    throws

     

     

    如果一个方法可以导致一个异常但不处理它,它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。做到这点你可以在方法声明中包含一个throws子句。一个throws子句列举了一个方法可能引发的所有异常类型。这对于除Error或RuntimeException及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的异常必须在throws子句中声明。如果不这样做,将会导致编译错误。

    下面是包含一个throws子句的方法声明的通用形式:

    typemethod-name(parameter-list)throwsexception-list

    {

    //bodyofmethod

    }

    这里,exception-list是该方法可以引发的以有逗号分割的异常列表。

    下面是一个不正确的例子。该例试图引发一个它不能捕获的异常。因为程序没有指定一个throws子句来声明这一事实,程序将不会编译。

    //Thisprogramcontainsanerrorandwillnotcompile.

    classThrowsDemo{

    staticvoidthrowOne(){

    System.out.println("InsidethrowOne.");

    thrownewIllegalAccessException("demo");

    }

    publicstaticvoidmain(Stringargs[]){

    throwOne();

    }

    }

    为编译该程序,需要改变两个地方。第一,需要声明throwOne()引发IllegalAccessException异常。第二,main()必须定义一个try/catch语句来捕获该异常。

    正确的例子如下:

    //Thisisnowcorrect.

    classThrowsDemo{

    staticvoidthrowOne()throwsIllegalAccessException{

    System.out.println("InsidethrowOne.");

    thrownewIllegalAccessException("demo");

    }

    publicstaticvoidmain(Stringargs[]){

    try{

    throwOne();

    }catch(IllegalAccessExceptione){

    System.out.println("Caught"+e);

    }

    }

    }

    下面是例题的输出结果:

    insidethrowOne

    caughtjava.lang.IllegalAccessException:demo

    finally

     

     

    当异常被引发,通常方法的执行将作一个陡峭的非线性的转向。依赖于方法是怎样编码的,异常甚至可以导致方法过早返回。这在一些方法中是一个问题。例如,如果一个方法打开一个文件项并关闭,然后退出,你不希望关闭文件的代码被异常处理机制旁路。finally关键字为处理这种意外而设计。finally创建一个代码块。该代码块在一个try/catch块完成之后另一个try/catch出现之前执行。finally块无论有没有异常引发都会执行。如果异常被引发,finally甚至是在没有与该异常相匹配的catch子句情况下也将执行。

    一个方法将从一个try/catch块返回到调用程序的任何时候,经过一个未捕获的异常或者是一个明确的返回语句,finally子句在方法返回之前仍将执行。这在关闭文件句柄和释放任何在方法开始时被分配的其他资源是很有用的。finally子句是可选项,可以有也可以无。然而每一个try语句至少需要一个catch或finally子句。

    下面的例子显示了3种不同的退出方法。每一个都执行了finally子句:

    //Demonstratefinally.

    classFinallyDemo{

    //Throughanexceptionoutofthemethod.

    staticvoidprocA(){

    try{

    System.out.println("insideprocA");

    thrownewRuntimeException("demo");

    }finally{

    System.out.println("procA'sfinally");

    }

    }

     

    //Returnfromwithinatryblock.

    staticvoidprocB(){

    try{

    System.out.println("insideprocB");

    return;

    }finally{

    System.out.println("procB'sfinally");

    }

    }

    //Executeatryblocknormally.

    staticvoidprocC(){

    try{

    System.out.println("insideprocC");

    }finally{

    System.out.println("procC'sfinally");

    }

    }

     

    publicstaticvoidmain(Stringargs[]){

    try{

    procA();

    }catch(Exceptione){

    System.out.println("Exceptioncaught");

    }

    procB();

    procC();

    }

    }

    该例中,procA()过早地通过引发一个异常中断了try。Finally子句在退出时执行。procB()的try语句通过一个return语句退出。在procB()返回之前finally子句执行。在procC()中,try语句正常执行,没有错误。然而,finally块仍将执行。

    注意:如果finally块与一个try联合使用,finally块将在try结束之前执行。

    下面是上述程序产生的输出:

    insideprocA

    procA’sfinally

    Exceptioncaught

    insideprocB

    procB’sfinally

    insideprocC

    procC’sfinally

    Java的内置异常

     

     

    在标准包java.lang中,Java定义了若干个异常类。前面的例子曾用到其中一些。这些异常一般是标准类RuntimeException的子类。因为java.lang实际上被所有的Java程序引入,多数从RuntimeException派生的异常都自动可用。而且,它们不需要被包含在任何方法的throws列表中。

    Java语言中,这被叫做未经检查的异常(uncheckedexceptions)。因为编译器不检查它来看一个方法是否处理或引发了这些异常。java.lang中定义的未经检查的异常列于表10-1。表10-2列出了由java.lang定义的必须在方法的throws列表中包括的异常,如果这些方法能产生其中的某个异常但是不能自己处理它。这些叫做受检查的异常(checkedexceptions)。Java定义了几种与不同类库相关的其他的异常类型。

    表8-1Java的java.lang中定义的未检查异常子类

     

     

    表8-2java.lang中定义的检查异常

     

    创建自己的异常子类

     

     

    尽管Java的内置异常处理大多数常见错误,你也许希望建立你自己的异常类型来处理你所应用的特殊情况。这是非常简单的:只要定义Exception的一个子类就可以了(Exception当然是Throwable的一个子类)。你的子类不需要实际执行什么——它们在类型系统中的存在允许你把它们当成异常使用。

    Exception类自己没有定义任何方法。当然,它继承了Throwable提供的一些方法。因此,所有异常,包括你创建的,都可以获得Throwable定义的方法。这些方法显示在表8-3中。你还可以在你创建的异常类中覆盖一个或多个这样的方法。

    表8-3Throwable定义的方法

     

    下面的例子声明了Exception的一个新子类,然后该子类当作方法中出错情形的信号。

    它重载了toString()方法,这样可以用println()显示异常的描述。

    //Thisprogramcreatesacustomexceptiontype.

    classMyExceptionextendsException{

    privateintdetail;

     

    MyException(inta){

    detail=a;

    }

     

    publicStringtoString(){

    return"MyException["+detail+"]";

    }

    }

     

    classExceptionDemo{

    staticvoidcompute(inta)throwsMyException{

    System.out.println("Calledcompute("+a+")");

    if(a>10)

    thrownewMyException(a);

    System.out.println("Normalexit");

    }

     

    publicstaticvoidmain(Stringargs[]){

    try{

    compute(1);

    compute(20);

    }catch(MyExceptione){

    System.out.println("Caught"+e);

    }

    }

    }

    该例题定义了Exception的一个子类MyException。该子类非常简单:它只含有一个构造函数和一个重载的显示异常值的toString()方法。ExceptionDemo类定义了一个compute()方法。该方法引发一个MyException对象。当compute()的整型参数比10大时该异常被引发。

    main()方法为MyException设立了一个异常处理程序,然后用一个合法的值和不合法的值调用compute()来显示执行经过代码的不同路径。下面是结果:

    Calledcompute(1)

    Normalexit

    Calledcompute(20)

    CaughtMyException[20]

    使用异常

     

     

    异常处理为控制具有很多动态运行时特性的复杂程序提供了一个强大的机制。把try,throw,和catch当成处理错误简洁及程序逻辑上的反常边界条件是很重要的。如果你像多数程序员一样,那么你可能习惯于在方法失败时返回一个错误代码。在你用Java编程时,你应该打破这个习惯。当方法可能失败时,引发一个异常。这是处理失败模式的一个更简洁的方法。

    最后说明一点:Java的异常处理语句不应该被当作是一个非本地分支的通常机制,如果你这样认为,它将困扰你的代码并使代码难于维护。



    实践问题:

     

     

    1.你是一名桥梁专家,结果在一次设计并实施一座大桥时,因为图纸上的一个小小的失误,在施工过程中没有发现,直到桥建成后才发现;结果导致整个大桥建成后出现很大的质量问题;你很后悔为什么当时不专门找几个人负责质量的监督工作呢?这个案例与我们今天学的异常有什么异同处?

     

     



    小结:

     

     

    在本章中,我们主要学习了:

     

    u      Java如何处理异常;

    u      常见异常的认识及自定义异常类;

     

     



    英语词汇:

     

     

    英文                    全文                                  中文

     

    Exception     Exception            异常

    Try        Try               尝试

    Catch         Catch                捕捉,抓住

    Throw         Throw                抛出,引发

    Finally       Finally              最终

     

     



    练习项目:

     

     

    有一个汽车修理工,正在检修汽车;结果发现有些问题修理过程中反复出现,但问题非常难解决;最后还是专门增加了人手后,问题慢慢明朗;汽车故障得到彻底解决;用今天学到的知识,做一个这个案例的模拟;

    展开全文
  • 一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...

    一门永不过时的编程语言——Java 软件开发。

    Java编程语言占比:

    据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员的数量最多。而在以Java编程为核心的开发领域中,javaEE程序员的需求量10年来一直居于首位!

    Java工程师就业:

    1.通过各大招聘网站统计,全国海量公司都在招聘Java开发工程师

    2.北京Java开发工程师平均薪资,即16788元

    3.全国Java开发薪资前三:北京 上海 广州

    javacto.taobao点com

    工具/原料

    • Java学习路线

    • Java学习大纲

    Java基础课程

    1. 1

      Java基础课程内容涉及:Java开发介绍、Java数组、Java面向对象、常用基础类、集合、IO流、多线程、异常、反射。

    2. 2

      第一部分:Java开发介绍

      1. DOS常用命令

      2. JVM、JRE、JDK之间的关系

      3. Java开发环境的搭建:安装JDK,配置环境变量

      4. Java入门程序(Java的开发流程)

      5. Java的注释,标识符、标识符的命名规范

      6. Java基本数据类型

      7. 变量和常量的定义及初始化

      8. Java的运算符

      9. 运算符的优先级

      10. Java分支语句之if...else

      11. 循环的嵌套

      12. 方法的定义

      13. 方法的形参和实参

      14. 方法的递归调用

    3. 3

       

      第二部分:Java数组

      1. Java 数组的定义

      2. Java 数组的声明

      3. 数组的优势与局限

      4. 数组的遍历访问(普通循环,增强for循环)

      5. 数组元素的顺序查找

      6. 数组元素的冒泡法排序

      7. Arrays工具类的使用

      8. 二维数组

    4. 4

       

      第三部分:Java面向对象

      1. 面向对象设计思想

      2. 面向对象的分析与设计

      3. Java与面向对象

      4. 类中成员变量的定义与意义

      5. 构造方法的定义和调用

      6. 面向对象的封装特性

      7. 局部变量和成员变量的作用域问题

      8. 静态属性、静态方法、静态代码块

      9. 面向对象的继承特性

      10. 继承中构造方法的细节

      11. 面向对象的多态特性

      12. 抽象方法与抽象类

      13. 接口

       

    5. 5

      第四部分:异常

      1. 异常的概念

      2. 异常的分类

      3. 异常的理解

      4. 常见异常介绍

      5. 运行时异常

      6. 编译时异常

      7. 运行和编译异常区别

      8. 异常的处理方式之捕获异常

      9. 异常的处理方式之抛出异常

      10. 异常的处理方式之断点调试

      11. 断点调试之引导运行步骤

      12. 自定义异常

      13. 异常关键字处理

      14. 关键字执行流程

      15. 异常总结

    6. 6

       

      第五部分:集合

      1. 集合的概念和作用

      2. 集合和数组的区别

      3. 集合框架体系介绍

      4. 集合框架之Collection接口

      6. ArrayList和LinkedList的方法使用

      7. ArrayList和LinkedList各自的工作原理分析原理分析

      8. 使用多种方式遍历集合

      9. HashSet和LinkedHashSet各自的工作原理分析

      10. 集合框架之Map接口

      11. 泛型的使用

      12. Collections工具类的使用

       

    7. 7

      第六部分:IO流

      1. File类的作用

      2. File类中常用方法的使用介绍

      3. 使用File类操作文件和文件夹

      4. 相对路径和绝对路径的介绍

      5. IO流的概念和工作原理

      6. IO流的分类

      7. 文件流的使用

      8. 转换流的使用

      9. 缓冲流的使用

      10. 对象流的使用

      11. 内存流的使用

      12. 使用不同的流实现文件内容的拷贝

    8. 8

      第七部分:多线程

      1. 进程和线程的介绍

      2. 进程和线程之间的区别与联系

      3. 线程实现方式之继承自Thread类

      4. 线程实现方式之实现Runnable接口

      5. 线程实现方式之线程池

      6. 线程的生命周期

      7. 线程中常用方法的使用

      END

    第二阶段:JavaWeb

    1. 1

      JavaWeb课程内容涉及:HTML5课程、CSS3、JavaScript、MySQL使用、JDBC连接池、Servlet、JSP、AJAX、jQuery、Bootstrap。

    2. 2

      第一部分:HTML5

      1. html概述

      2. html基本标签

      3. 图片标签

      4. 超链接标签

      5. 表格标签

      6. 无序列表标签

      7. 有序列表标签

      8. 定义列表标签

      9. div标签

      10. 语义化标签

      11. 表单标签

    3. 3

       

      第二部分:CSS3

      1. CSS3简介和用途

      2. CSS3书写规范

      3. CSS3基本语法

      4. CSS3三种使用方式

      5. 标签选择器

      6. Id选择器

      7. Class选择器

      8. 属性选择器

      9. 层次选择器

      10. 文字、文本属性

      11. 背景、列表属性

      12. 尺寸、显示、轮廓属性

      13. 浮动、定位属性

      14. 盒子模型

      15. CSS3高级属性

       

    4. 4

       

      第三部分:JavaScript

      1. JavaScript概述

      2. JavaScript发展史

      3. JavaScript组成

      4. 数据类型

      5. 运算符

      6. 分支语句

      7. 循环语句

      8. 系统函数、自定义函数、匿名函数

      9. 常见事件

      10. 数组、字符串、日期对象

      11. 正则表达式

      12. BOM对象:window、history、location

      13. DOM概念

      14. DOM操作:创建、修改内容、删除

      15. Css样式操作

       

    5. 5

      第四部分:MySQL使用  或oracle数据库

      1. 数据库简介

      2. MySQL的安装与使用

      3. MySQL客户端和服务器配置

      4. 用户权限管理

      5. DDL创建数据库和表

      6. 约束与外键

      7. DML实现添加、修改、删除数据

      8. 聚合函数、日期函数等

      9. DQL简单查询

      10. 排序、分组、筛选

      11. 多表查询

      12. 子查询

      13. in和exists关键字

      14. 分页查询

      15. Mysql SQL语句优化介绍

    6. 6

      第五部分:JDBC连接池

      1. JDBC概述

      2. JDBC使用步骤

      3. Connection、Statement、ResultSet接口

      4. 使用JDBC 完成数据库DML操作

      5. PreparedStatement对象

      6. 大数据的操作

      7. 批量处理与元数据

      8. 事务处理

      9. 隔离级别

      10. 自定义连接池

      11. DBCP、C3p0连接池

      12. DBUtis工具类

      13. QueryRunner

      14. 自定义结果集处理

      15. 连接池知识总结

    7. 7

      第六部分:Servlet

      1. Tomcat与Eclipse的集成开发

      2. 什么是Servlet

      3. Servlet的进化史

      4. Servlet的优化过程

      5. Servlet中应用的多线程概念

      6. Servlet接收客户端请求信息

      7. Servlet响应客户端信息

      8. Servlet的生命周期

      9. 重定向写法

      10. 转发写法

      11. 转发和重定向区别

      12. HttpServletRequest获取中文乱码问题

      13. HttpServletResponse响应中文乱码问题

      14. Servlet路径映射问题

      15. Servlet多路径映射

    8. 8

      第七部分:JSP

      1. 什么是JSP

      2. JSP的内置对象

      3. 透析JSP的本质

      4. JSTL+EL

      5. MVC介绍

      6. 分层的重要性

      7. Web工程中事务实现

      8. Session的使用

      9. Cookie的使用

      10. web工程中连接池的使用

      11. 实现用户的自动登录

      12. 文件的上传、下载

      13. 过滤器、 监听器

      14. 反射、注解、泛型

      15. 综合案例练习

    9. 9

      第八部分:AJAX

      1. Ajax技术背景

      2. Ajax技术的理解

      3. XMLHttpRequest使用步骤

      4. XMLHttpRequest GET/POST的区别

      5. 同步请求&异步请求

      6. 同步请求&异步请求的区别

      7. Ajax获取不同的返回值类型

      8. Ajax使用原生JavaScript和Jquery的区别

      9. Ajax响应状态处理

      10. JSON语法

      11. Java JSON 解析

      12. Java JSON 生成

      13. Java JSON 第三方工具快速解析

      14. JavaScript JSON转换

      15. Jquery JSON转换

      END

    Java框架课程

    1. 1

      Java框架课程内容涉及:Spring、Spring MVC、MyBatis、SVN、Git、Maven、SpringBoot

    2. 2

      第一部分:Spring

      1. 框架原理介绍

      2. 框架环境搭建

      3. 快速入门

      4. 创建Bean的方式及实现原理

      5. Bean种类

      6. Bean生命周期

      7. Bean的作用域

      8. Bean的注值方式

      9. 整合Junit测试

      10. 注解装配Bean

      11. 注解装配Bean

      12. AOP思想、原理解剖

      13. AOP底层JDK动态代理

      14.AOP编程

      15. AspectJ介绍及实现AOP开发

      16.事务

      17. Web项目集成Spring

    3. 3

      第二部分:Spring MVC

      1. Spring MVC 概述

      2. 使用 @RequestMapping映射请求

      3. 请求处理方法签名概述

      4. 处理方法签名详细说明

      5. 使用 HttpMessageConverter

      6. 处理模型数据

      7. 数据绑定流程剖析

      8. 数据格式化

      9. 数据校验

      10. 视图和视图解析器

      11. 处理方法的数据绑定

      12. 视图和视图解析器

      13. 文件上传下载

      14. JSON处理

      15. 拦截器

    4.  

      第三部分:MyBatis

      1. MyBatis数据框架介绍

      2. MyBatis对比Hibernate框架

      3. MyBatis配置、查询数据

      4. MyBatis全局配置文件

      5. MyBatis全局配置文件元素详细介绍

      6. Mapper映射文件

      7. MyBatis两种开发方式

      8. MyBatis中别名配置

      9. MyBatis # 和 $ 拼接参数区别

      10. 关联查询,动态sql

      11. MyBatis缓存机制、整合ehcache

      12. MyBatis二级缓存处理

      13. MyBatis、Spring、SpringMVC整合

      14. 分页插件

      15. MyBatis逆向工程

       

    5. 第四部分:SVN   和git

      1. SVN简介

      2. SVN和Git对比

      3. SVN服务器搭建

      4. SVN创建仓库

      5. SVN创建用户以及分配权限

      6. SVN签出、提交、更新

      7. Eclipse整合svn插件

      8. Idea整合svn插件

      9. 使用SVN更新提交

      10. SVN仓库分析

      11. SVN协同修改&冲突解决

      12. SVN代码整合注意事项

      13. SVN权限管理

      14. SVN数据回滚

      15. TortoiseSVN

    6. 6

      第五部分:Maven

      1. Maven环境搭建

      2. Maven构建项目

      3. Maven本地仓库配置

      4. Maven中央仓库配置

      5. Maven基本概念

      6. Maven基本命令介绍

      7. Maven于Eclipse整合

      8. Maven于Idea整合

      9. Maven创建web工程

      10. pom.xml、依赖管理

      11. 坐标、依赖、生命周期等

      12. Eclipse下的Maven使用

      13. Maven中 继承、聚合

      14. Maven构建SSH/SSM应用

      15. 自动部署、持续集成、持续部署

    7. 第六部分

      项目开发

    Java企业级课程  javacto点taobao点com

     

    展开全文
  • Java学习路线图的第二阶段是Java语言进阶学习,在学习完第一阶段的Java语言入门后,大家对Java语言编程有了初步的认识。 黑马程序员的2020最新版Java学习路线图把Java语言进阶学习分为九个部分:面向对象进阶,常见...

    Java学习路线图的第二阶段是Java语言进阶学习,在学习完第一阶段的Java语言入门后,大家对Java语言编程有了初步的认识。

    黑马程序员的2020最新版Java学习路线图把Java语言进阶学习分为九个部分:面向对象进阶,常见API,异常,集合,IO,多线程,网络编程,Lambda以及反射。

    下面介绍的是Java语言进阶学习阶段的技术要点,跟着学一定会有所收获。如果在被某个知识点卡住了,请不要轻易放弃,继续往下面学,等学到一定时候你会对不懂的知识点恍然大悟。

    黑马程序员 Java语言进阶技术要点

    面向对象进阶

    1. 面向对象特性之继承
    2. 继承的好处和弊端
    3. super关键字的作用
    4. 继承时子父类的访问特点
    5. super的内存分析
    6. 方法的重写(Override)
    7. package关键字的作用
    8. import关键字的作用
    9. final关键字的作用
    10. final修饰局部变量的注意事项
    11. static关键字的作用
    12. 面向对象特性之多态
    13. 多态的好处和弊端
    14. 多态中成员访问的特点
    15. 多态中的数据类型转型
    16. 内存分析多态的转型
    17. 抽象类的特点
    18. 抽象类的成员特点
    19. 接口的概述
    20. 接口的特点和注意事项
    21. 类、抽象类、接口之间的关系
    22. 内部类的概述
    23. 成员内部类的使用
    24. 局部内部类的使用
    25. 匿名内部类的使用
    26. 匿名内部类在开发中的应用

    常用API

    1. Math类及其常用方法
    2. System类及其常用方法
    3. Object类的toString()和equals()方法
    4. Arrays类及其常用方法
    5. 冒泡排序的原理分析及代码实现
    6. 基本类型的包装类
    7. 自动拆箱和自动装箱
    8. 日期Date类型及其常用方法
    9. 日期格式化类SimpleDateFormat
    10. 日期工具类的编写
    11. 日历Calendar类的使用

    异常

    1. 异常的概述
    2. JVM默认处理异常的方式
    3. 异常处理方式之try…catch
    4. 异常处理方式之throws
    5. Throwable的常用方法
    6. 异常的分类和区别
    7. 自定义异常的使用

    集合

    1. 集合体系结构
    2. 单列集合体系的详细讲解
    3. 迭代器的使用
    4. 增强for循环的使用
    5. 并发修改异常的产生原因和解决办法
    6. 数据结构之栈和队列
    7. 数据结构之数组和链表
    8. 数据结构之哈希表
    9. HashSet保证元素唯一的源码分析
    10. TreeSet的自然排序和比较器排序
    11. 泛型的使用
    12. 泛型通配符的使用
    13. 可变参数的使用和注意事项
    14. 双列集合体系的详细讲解
    15. Map集合的遍历方式
    16. 集合的嵌套操作
    17. 集合练习之斗地主案例

    IO

    1. File类对文件的操作
    2. 递归的应用和注意事项
    3. IO流的概述和分类
    4. 字节流写数据的方式
    5. 字节流读数据的方式
    6. 字节流完成图片的复制
    7. 字符缓冲流的使用
    8. 编码表
    9. 字符流写数据的方法
    10. 字符串读数据的方法
    11. 字符缓冲流的特有方法
    12. 点名器案例
    13. IO流完成文件夹的复制
    14. 标准输入输出流
    15. 打印流的使用
    16. 对象序列化流
    17. serialVersionUID&transient
    18. Properties的用法

    多线程

    1. 进程和线程的区别
    2. Java实现多线程的两种方式
    3. 线程优先级的设置和获取
    4. 线程的控制
    5. 线程的生命周期
    6. 线程的安全问题
    7. 同步代码块
    8. 同步方法
    9. Lock锁
    10. 生产者消费者问题

    网络编程

    1. 网络编程的概述
    2. 网络编程的三要素
    3. InetAddress类的操作
    4. 端口和协议的详细解释
    5. UDP协议发送与接收数据
    6. TCP协议发送与接收数据
    7. 模拟客户端与服务端数据传输
    8. 多线程下文件的上传

    Lambda

    1. Lambda表达式的标准写法
    2. Lambda的省略规则
    3. Lambda和匿名内部类的区别
    4. JDK8和9对接口组成的更新
    5. 方法引用的介绍
    6. 函数式接口
    7. Stream流的中间操作
    8. Stream流的终结操作
    9. Stream流的收集操作

    反射

    1. 类加载过程
    2. 类加载器
    3. 反射机制的概述
    4. 获取Class类的对象
    5. 反射获取构造方法并使用
    6. 反射获取成员方法并使用
    7. 反射获取成员变量并使用
    8. 反射之泛型翻越
    9. 模块化的概述
    10. 模块服务的使用
    展开全文
  • 深知广大爱好Java的人学习是多么困难,没视频没资源,上网花钱还老被骗。为此我呕心沥血整理了这套Java教程,不管你是不懂电脑的小白,还是已经步入开发的大牛,这套路线路你都值得拥有,小白看上面的视频可以成功...
  • 一、Java基础 Java基础-继承 Java基础-抽象 Java基础-接口 Java基础-多态 Java基础-重写 Java基础-匿名对象 Java基础-内部类 Java基础-final、static关键字 Java基础-ArrayList集合 ...
  • 一门永不过时的编程语言——Java 软件开发,虽然我是做C/C++开发的,但是也是学习过并且之后肯定还要继续学习Java的,原因就是5G时代,万物互联,更多的终端会使用安卓系统,随之而来的Java开发必然是会越来越火爆,...
  • 2016最新Java学习计划

    2018-04-02 23:05:53
    一、Java学习路线图 二、Java学习路线图——视频篇 六大阶段学完后目标知识点配套免费资源(视频+笔记+源码+模板)密码 第一阶段Java基础 入门学习周期:35天学完后目标:1.可进行小型应用程序开发2.对数据库进行...
  • 一、 异常测试 对可能抛出的异常进行测试: 异常本身是方法签名的一部分: public static int parselnt(String s) throws NumberFormatException 测试错误的输入是否导致特定的异常: • Integer.parselnt(null) • ...
  • 前两天腾讯面试官问了我这样一个问题,为什么java要引入异常处理机制,让程序崩溃不是很不友好么?我之前也没思考过这个问题,临场发挥,想了想给出了这么一个回答:“发生了异常,说明程序已经发生错误了,如果不...
  • Javaweb系统学习路线:Java系统学习路线:第一阶段技术名称第一阶段: Java 基础,包括 Java 语法,面向对象特征,常见API,集合框架。(基础)第二阶段:Java API:输入输出,多线程,网络编程,反射注解等,Java 的...
  • 千锋教育2019最新java学习教程汇总(学习路线+课程大纲+视频教程+面试题+学习工具) 目录 一、首先要了解什么是JAVA? 二、Java发展及就业前景分析 三、Java学习路线图 四、Java课程大纲 五、JAVA视频教程汇总...
  • Java后端学习流程

    2017-12-19 12:10:44
    首先,我个人比较推崇的学习方法是:先学java前端,也就是HTML,css,js,因为学习java以后肯定是往java ee方向发展的,学习完前端,在学习后端很多东西比计较容易理解! 其中J2SE是关键,如果学好了java se 部分,...
  • spring异常拦截背景在springmvc的...学习目标学习全局异常拦截器处理controller所有异常的返回封装定义枚举异常码,优雅的设计自定义异常经典案例--------------创建枚举异常码,系统所有异常情况在这里定义就是---...
  • 摘要:想来学习Java也有两个年头了,永远不敢说多么精通,但也想谈谈自己的感受,写给软件学院的同仁们,帮助大家在技术的道路上少一点弯路。说得伟大一点是希望大家为软件学院争气,其实最主要的还是大家自身的进步...
  • 如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常。 ArrayIndexOutOfBoundsException 原因:索引编号写错了。 解决:修改成存在的正确索引编号。 ————————————————————...
  • 从不知java为何物到现在一个小小的j2ee项目经理虽说不上此道高手,大概也算有点斤两了吧每次上网,泡bbs逛论坛,没少去java相关的版 面总体感觉初学者多,高手少,精通的更少由于我国高等教育制度教材陈旧,加上java...
  • java后端学习流程

    2017-06-09 11:38:43
    java后端学习流程  首先,我个人比较推崇的学习方法是:先学java前段,也就是HTML,css,js,因为学习java以后肯定是往java ee方向发展的,学习完前端,在学习后端很多东西比计较容易理解!  其中J2SE是...
  •  这篇博客的灵感来自于我在实际工作中,发现 Runnable接口的run方法不可以在方法上抛出异常,如果有编译时异常,那么只能在方法内部进行 try-catch ,这个知识点成功引起了我的注意。于是,这...
1 2 3 4 5 ... 20
收藏数 26,163
精华内容 10,465
关键字:

java异常学习案例