抓到try-catch块错误后继续执行

Question

捕获异常后，如何继续执行Java程序？

所以我做了一个程序来从双向链表的特定位置插入或删除节点。 这两种方法抛出异常。

在 main 方法中，我已经开始向位置插入一些 int 值。 如果我输入了错误的 pos 值，插入方法会抛出错误并捕获块句柄。

1. 如果我输入了 30 个节点并将它们插入正确的位置，除了 1 个节点。 - 错误输入后（即在插入中间）如何继续插入 rest？

    public static void main(String[] args) {
        LinkedList myList = new LinkedList();
        try {
            myList.Insert(1, 0);
            myList.Insert(5, 54); //  this is the false entry
            myList.Insert(1, 0);
            myList.Insert(1, 0);
        
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        myList.Out();
        myList.ReverseOutput();     

      }

    }

So after execution, the output is 1. How can I make it [1 , 1 , 1]?

Answer 1

您可以将myList.insert包装在忽略异常的方法中，然后改用它：

static void insertAndIgnoreException(LinkedList list, int position, int value) {
  try {
    list.Insert(position, value);
  } catch (LinkedListInsertionException e) {
    System.out.println(e.getMessage());
  }
}

所以你的主要变成：

public static void main(String[] args) {
        LinkedList myList = new LinkedList();
        insertAndIgnoreException(1, 0);
        insertAndIgnoreException(5, 54); //  this is the false entry
        insertAndIgnoreException(1, 0);
        insertAndIgnoreException(1, 0);

        myList.Out();
        myList.ReverseOutput();     

  }

一些注意事项：

1. 我使用了特定的异常类型LinkedListInsertionException 。 永远不要捕获并忽略Exception ，因为您最终会错过所有其他问题，例如NullPointerException 。
2. 在代码中坚持 Java 命名约定。 即insert不Insert 。
3. 不要重复使用 JDK class 名称，即使用MyLinkedList而不是LinkedList 。

Answer 2

在此示例中，您可以使用循环来解决此问题。

就像是：

int[] numsToInsert = new int[] {1, 0, 5, 54, 1, 0, 1, 0};

for(int i = 0; i < 8; i += 2){
    try {
        myList.Insert(numsToInsert[i], numsToInsert[i + 1]);
    } catch (Exception ex) {
        System.out.println(ex.toString());
    }
}

这将通过迭代执行插入来分别捕获每次插入的异常。

Answer 3

简短的回答是：你不知道。

...但这并不意味着您无能为力。

try/catch 的目的是在检测到错误后停止所有处理。 它的目的是跳过代码的 rest（一直到捕获）。 它正在做它应该做的事情，就像说“跳过我”一样。

所以你的问题“我如何运行代码的 rest”只能通过从“跳过我”指令中删除代码来实现。

        try {
            myList.Insert(1, 0);
            myList.Insert(5, 54); //  this is the false entry
        
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        myList.Insert(1, 0);
        myList.Insert(1, 0);
        myList.Out();
        myList.ReverseOutput();   

这将为您提供您期望的 output。

……但感觉不太对

如果我们从try中删除代码，那么 try 似乎不值得拥有。 问题是，那个 try 块出于某种原因被放在那里。 Try 块应该捕获错误并且它成功地做到了，所以显然它做了一些有用的事情，并且从中取出代码感觉像是错误的解决方案。

我们想要的是每一行代码都要试，如果失败了，再试下一行。 注意我说try不止一次，还有“每一个”

        try {
            myList.Insert(1, 0);
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        try {
            myList.Insert(5, 54); //  this is the false entry
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        try {
            myList.Insert(1, 0);
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        try {
            myList.Insert(1, 0);
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }

这还将为您提供所需的 output，并处理任何引发错误的插入。

……但感觉不太对

那是很多重复的文本，只是为了一遍又一遍地做同样的插入。 如果我们有办法重复事情就好了？

int values[4][2] = {
    {1,0},
    {5,54},
    {1,0},
    {1,0}
};

for(int v[2] : values){
    try {
        myList.Insert(v[0], v[1]);
    } catch (Exception ex) {
        System.out.println(ex.toString());
    }
}

这将为您提供所需的 output，处理任何引发错误的插入，并避免不断重复。

……但感觉不太对

该原始代码没有使用循环。 我认为这是有原因的：可能它是一个测试存根，最终将从其他地方接收值。

这表明独立测试每个项目是此代码的实际目的。 如果是这样，有一种方法可以让单行代码处理它自己的错误：

function TryInsert(list,pos,val){
    try {
        list.Insert(pos, val);
        return true;
    } catch (Exception ex) {
        System.out.println(ex.toString());
        return false;
    }
}

...

TryInsert(mylist, 1, 0);
TryInsert(mylist, 5, 54); //  this is the false entry
TryInsert(mylist, 1, 0);
TryInsert(mylist, 1, 0);

这将为您提供所需的 output，处理任何引发错误的插入，并且更符合最初的意图。

……但感觉不太对

鉴于您将myList object 传递给每个 function 调用，似乎要对 object 采取行动。 这表明这是您的Insert function 真正需要的行为。

也许您想更改 class，将这个 function 添加到其中，或者修改Insert以在错误发生时根据自己的最佳判断（直接或通过继承）采取行动。

myList.TryInsert(1, 0);
myList.TryInsert(5, 54); //  this is the false entry
myList.TryInsert(1, 0);
myList.TryInsert(1, 0);

鉴于我无权访问您的 class... 我将其作为练习留给读者。

重构很有趣