当变量被赋值时，Java从函数返回

如果变量（在函数内部）在任意点被赋值，是否可以离开函数。例如：

public class TestClass {
    public int doSomething() {
        int resultCode;
        
        resultCode = checkFirstThing() //Returns 0 if succeed or 1 if not
        //Exit if resultCode != 0
        
        resultCode = checkSecondThing() //Returns 0 if succeed or 2 if not
        //Exit if resultCode != 0

        resultCode = checkThirdThing() //Returns 0 if succeed or 3 if not
        //Exit if resultCode != 0

        //do Something if all clauses succeeded

        return resultCode
    }
}

我的问题是，我不想在每个检查函数之后添加

if（resultCode！=0）return resultCode

。
我自己什么也没找到，但因为有一些非常聪明的人在那里，我认为mybe别人知道一个比我现在的解决方案更好的方法（每次检查后的保护条款）

我知道我想要的可能是不可能的，但这个问题是为了确保

---

感谢您的帮助：）

您可以更改

checkX

方法以返回

布尔值（
true
表示成功，
false
表示失败），并将错误代码移到调用它们的方法（
doSomething（）
）：

您可以更改
checkX
方法以返回
布尔值（
true
表示成功，
false
表示失败），并将错误代码移动到调用它们的方法（
doSomething（）
）：

您可以为此编写一个高阶函数。实际上，您只想得到第一次检查的结果代码，该代码不是0，或者如果所有检查都返回0，则为0

public static int checkAll(IntSupplier... resultCodeSuppliers) {
    return Arrays.stream(resultCodeSuppliers)
        .mapToInt(IntSupplier::getAsInt)
        .filter(x -> x != 0)
        .findFirst().orElse(0);
}

这是因为流操作是懒惰的。当我执行
findFirst
时，它将只运行返回0的检查，再加上第一个返回非0的检查。在那之后，它不会再运行任何检查，因为我只要求它
findFirst

用法：

int resultCode = checkAll(
    () -> checkFirstThing(),
    () -> checkSecondThing(),
    () -> checkThirdThing()
);
if (resultCode == 0) { // you only need this one check
    // do the thing...
}
return resultCode;

您可以为此编写一个高阶函数。实际上，您只想得到第一次检查的结果代码，该代码不是0，或者如果所有检查都返回0，则为0

public static int checkAll(IntSupplier... resultCodeSuppliers) {
    return Arrays.stream(resultCodeSuppliers)
        .mapToInt(IntSupplier::getAsInt)
        .filter(x -> x != 0)
        .findFirst().orElse(0);
}

这是因为流操作是懒惰的。当我执行
findFirst
时，它将只运行返回0的检查，再加上第一个返回非0的检查。在那之后，它不会再运行任何检查，因为我只要求它
findFirst

用法：

int resultCode = checkAll(
    () -> checkFirstThing(),
    () -> checkSecondThing(),
    () -> checkThirdThing()
);
if (resultCode == 0) { // you only need this one check
    // do the thing...
}
return resultCode;

您可以使用Java8的
java.util.Optionant

公共类TestClass{
公共int doSomething（）{
返回optionant.of（checkFirstThing（））
.map（x->x！=0？x:checkSecondThing（））
.map（x->x！=0？x:checkThirdThing（））
.getAsInt（）；
}
}

然而，与零的比较是不可避免的，因为您需要的是布尔值而不是int值。
也许您可以创建一个包装函数来比较零，并使用
optionant.empty（）
来避免三元运算符。
您可以使用java 8的
java.util.optionant

公共类TestClass{
公共int doSomething（）{
返回optionant.of（checkFirstThing（））
.map（x->x！=0？x:checkSecondThing（））
.map（x->x！=0？x:checkThirdThing（））
.getAsInt（）；
}
}

然而，与零的比较是不可避免的，因为您需要的是布尔值而不是int值。
也许您可以创建一个包装函数来比较零，并使用
optionant.empty（）
来避免三元运算符。
我突然想到的一种方法是，如果操作成功，您可以让方法
返回1
，否则
抛出异常

然后，您可以将所有对方法的调用放入一个
try…catch
语句中，如果出现任何异常，您只需从
catch
语句返回即可

祝你好运：）


公共类TestClass{
公共int doSomething（）{
int-resultCode；
试一试{
resultCode=checkFirstThing（）；//如果成功，则返回1
//如果引发异常，则退出
resultCode=checkSecondThing（）；//如果成功，则返回1
//如果引发异常，则退出
resultCode=checkThirdThing（）；//如果成功，则返回1
//如果引发异常，则退出
}catch（/*类异常*/）{返回0；/*失败*/}
//如果所有的子句都成功了，就做些什么
返回结果代码；
}
}
我突然想到的一种方法是，如果操作成功，您可以让方法
返回1
，否则抛出异常

然后，您可以将所有对方法的调用放入一个
try…catch
语句中，如果出现任何异常，您只需从
catch
语句返回即可

祝你好运：）


公共类TestClass{
公共int doSomething（）{
int-resultCode；
试一试{
resultCode=checkFirstThing（）；//如果成功，则返回1
//如果引发异常，则退出
resultCode=checkSecondThing（）；//如果成功，则返回1
//如果引发异常，则退出
resultCode=checkThirdThing（）；//如果成功，则返回1
//如果引发异常，则退出
}catch（/*类异常*/）{返回0；/*失败*/}
//如果所有的子句都成功了，就做些什么
返回结果代码；
}
}
<代码> > p>您可以考虑Spring框架来解决这种情况。看


并使用方法上名为@transactional的注释。如果所有子方法都无例外地返回success，则可能导致方法进程成功。否则，它会导致方法进程的回滚。
 
可以考虑Spring框架来解决这种情况。看

并使用方法上名为@transactional的注释。如果所有子方法都无例外地返回success，则可能导致方法进程成功。否则，它可能导致回滚方法进程。
正确的方法是使用result对象（在其自己的类中实现）。该对象由一个代码组成，如果检查成功，则由被调用的方法（如checkFirstThing）设置该代码。对象是