Java：处理异常并从内部方法返回结果

问题：如何处理两者：在

外部

方法中处理异常，并返回

内部

方法的结果

我有：两个返回

列表的方法：

import java.util.List;
import java.util.LinkedList;

public class HelloWorld {

     public static void main(String[] args){
        System.out.println("Result = " + new HelloWorld().parseWrapper()); 
     }

     public List<Integer> inner() {
         List<Integer> list = new LinkedList<Integer>();
         for (int i = 0; i < 5; i++) {
             if (i % 4 == 0) throw new RuntimeException();
             list.add(i);
         }
         return list;
     }

     public List<Integer> outer() {
         List<Integer> list = null;
         try {
             list = parse();
         } catch (Exception e) {
             System.out.println("Handle exception!");
         } finally {
             return list;
         }
     }
}

问题：我丢失了结果列表。我想要两者：处理异常和从
外部方法返回[1,2,3]列表。
否-内部方法不返回任何内容，因为它会引发异常。外部方法根本没有可处理的结果

如果一个方法抛出了一个异常，一般认为该方法中的任何工作都没有用处

如果希望尽可能多地填充列表，可以将列表传递到方法中：

public void inner(List<Integer> list) {
    for (int i = 0; i < 5; i++) {
        if (i % 4 == 0) throw new RuntimeException();
        list.add(i);
    }
}

public void-internal（列表）{
对于（int i=0；i<5；i++）{
如果（i%4==0）抛出新的RuntimeException（）；
列表.添加（i）；
}
}

然后称之为：

public List<Integer> outer() {
    List<Integer> list = new LinkedList<>;
    try {
        parse(list);
    } catch (Exception e) {
        System.out.println("Handle exception!");
    } finally {
        return list;
    }
}

公共列表外部（）{
列表=新建链接列表；
试一试{
解析（列表）；
}捕获（例外e）{
System.out.println（“处理异常！”）；
}最后{
退货清单；
}
}

老实说，这很少是一个好主意——根据我的经验，大多数异常都不能真正得到处理和恢复；这更像是“找出需要清理的内容，以及要中止的工作单元”。当然，这并不是普遍正确的，但是您试图从方法中获得的部分结果很少有用。
否-内部方法不会返回任何内容，因为它会引发异常。外部方法根本没有可处理的结果

如果一个方法抛出了一个异常，一般认为该方法中的任何工作都没有用处

如果希望尽可能多地填充列表，可以将列表传递到方法中：

public void inner(List<Integer> list) {
    for (int i = 0; i < 5; i++) {
        if (i % 4 == 0) throw new RuntimeException();
        list.add(i);
    }
}

public void-internal（列表）{
对于（int i=0；i<5；i++）{
如果（i%4==0）抛出新的RuntimeException（）；
列表.添加（i）；
}
}

然后称之为：

public List<Integer> outer() {
    List<Integer> list = new LinkedList<>;
    try {
        parse(list);
    } catch (Exception e) {
        System.out.println("Handle exception!");
    } finally {
        return list;
    }
}

公共列表外部（）{
列表=新建链接列表；
试一试{
解析（列表）；
}捕获（例外e）{
System.out.println（“处理异常！”）；
}最后{
退货清单；
}
}

老实说，这很少是一个好主意——根据我的经验，大多数异常都不能真正得到处理和恢复；这更像是“找出需要清理的内容，以及要中止的工作单元”。当然，这并不是普遍正确的，但是您试图从方法中获得的部分结果很少有用。
您可以将列表实例带到类级别：

public class HelloWorld {
    private List<Integer> list = new LinkedList<>();

    public List<Integer> inner() {         
      for (int i = 0; i < 5; i++) {
         if (i % 4 == 0) throw new RuntimeException();
         list.add(i);
      }
      return list;
    }

    public List<Integer> outer() {
        try {
            parse();
        } catch (Exception e) {
            System.out.println("Handle exception!");
        } finally {
            return list;
        }
    }
}

您可以将列表实例带到类级别：

public class HelloWorld {
    private List<Integer> list = new LinkedList<>();

    public List<Integer> inner() {         
      for (int i = 0; i < 5; i++) {
         if (i % 4 == 0) throw new RuntimeException();
         list.add(i);
      }
      return list;
    }

    public List<Integer> outer() {
        try {
            parse();
        } catch (Exception e) {
            System.out.println("Handle exception!");
        } finally {
            return list;
        }
    }
}

创建一个
结果
对象，该对象具有
列表
和
异常
。返回该值。
new HelloWorld（）.parseWrapper（）
和
parse（）
方法中的
outer
都是语法错误。我们是否应该假设
外部
和
内部
最初被称为
parseWrapper
和
parse
？顺便说一句，从
最后
块返回通常被认为是一件坏事：而且，列表将是空的，它不会包含[1,2,3]，由于异常将在循环的第一次迭代中抛出，在列表中添加任何内容之前。请创建一个包含
列表
和
异常
的
结果
对象。返回该值。
new HelloWorld（）.parseWrapper（）
和
parse（）
方法中的
outer
都是语法错误。我们是否应该假设
外部
和
内部
最初被称为
parseWrapper
和
parse
？顺便说一句，从
最后
块返回通常被认为是一件坏事：而且，列表将是空的，它不会包含[1,2,3]，因为异常将在循环的第一次迭代中抛出，在列表中添加任何内容之前。