Java 当if语句失败时返回上一个if语句

我一周前才开始用Java编程，所以很抱歉所有的错误代码。 我一直在从一个我曾经玩过的游戏中重新创建一个“优化系统”，只是因为我认为这对于初学者项目来说是个好主意。该系统根据成功几率百分比改进装备。当您获得更高的细化度时，百分比概率会下降

我的项目中的一种细化方法是，每次失败的细化都不会将细化级别重置为0，而是在每次失败时将细化级别降低1

我已经成功地创建了一个在失败时重置为0的方法，但似乎不知道如何在失败时将级别降低1

所以我的问题是，我如何在失败时让我的“优化级别”降低1，而不是重置为0。此外，控制台需要在失败时返回到上一个IF语句，否则它将无法工作

这是我的尝试：

import java.util.Random;

public class Tisha {

    public static void main(String[] args) throws InterruptedException {

        if (new Random().nextDouble() <= 0.535) {
            System.out.println("Refine successful  -  Refine level 1");
        } else {
            System.out.println("Refine failed  -  Refine reset");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 2");
        } else {
            System.out.println("Refine failed  -  Refine level 1");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 3");
        } else {
            System.out.println("Refine failed  -  Refine level 2");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 4");
        } else {
            System.out.println("Refine failed  -  Refine level 3");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 5");
        } else {
            System.out.println("Refine failed  -  Refine level 4");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 6");
        } else {
            System.out.println("Refine failed  -  Refine level 5");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 7");
        } else {
            System.out.println("Refine failed  -  Refine level 6");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.335) {
            System.out.println("Refine successful  -  Refine level 8");
        } else {
            System.out.println("Refine failed  -  Refine level 7");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.285) {
            System.out.println("Refine successful  -  Refine level 9");
        } else {
            System.out.println("Refine failed  -  Refine level 8");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.235) {
            System.out.println("Refine successful  -  Refine level 10");
        } else {
            System.out.println("Refine failed  -  Refine level 9");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.155) {
            System.out.println("Refine successful  -  Refine level 11");
        } else {
            System.out.println("Refine failed  -  Refine level 10");
        }

        Thread.sleep(250);

        if (new Random().nextDouble() <= 0.085) {
            System.out.println("Refine successful  -  Refine level 12");
        } else {
            System.out.println("Refine failed  -  Refine level 11");
        }
    }

}

---

抱歉，代码太乱了，我警告过您。

将您的优化级别设置为一个变量，并相应地增加或减少

int refinementLevel = 0;

if (new Random().nextDouble() <= 0.155) {
  refinementLevel++;
  System.out.println("Refine successful  -  Refine level "+refinementLevel);
} else {
  refinementLevel--;
  System.out.println("Refine failed  -  Refine level "+refinementLevel);
}

int-refinementLevel=0；
如果（new Random（）.nextDouble（），您可能希望将其放入一个类中，以便对象包含当前级别，并“知道”根据哪个阈值检查下一个随机值以确定成功或失败。请注意这些检查以确保数组
级别
的访问不会超出其限制

public class Refinement {
    private static final double[] grade =
        { 0.535, 0.335, 0.335, 0.335,
        0.335, 0.335, 0.335, 0.335,
        0.285, 0.235, 0.155, 0.085 };
    private int level = 0;
    private Random rand = new Random();

    public int getLevel(){
        return level;
    }

    public void step(){
        int testlevel = level == grade.length ? grade.length - 1 : level;
        if( rand.nextDouble() <= grade[level] ){
            if( ++level >= grade.length ) level = grade.length;
        } else {
            if( --level < 0 ) level = 0;
        }
    }

    public static void main( String[] args ){
        Refinement refinement = new Refinement();
        for( int i = 1; i <= 20; ++i ){
            refinement.step();
            System.out.println( "level: " + refinement.getLevel() );
        }
    }
}

公共类细化{
私人静态最终双[]级=
{ 0.535, 0.335, 0.335, 0.335,
0.335, 0.335, 0.335, 0.335,
0.285, 0.235, 0.155, 0.085 };
私有整数级=0；
private Random rand=new Random（）；
public int getLevel（）{
回报水平；
}
公共无效步骤（）{
int testlevel=level==grade.length？grade.length-1:级别；
如果（rand.nextDouble（）=grade.length）level=grade.length；
}否则{
如果（-level<0）level=0；
}
}
公共静态void main（字符串[]args）{
细化=新的细化（）；
对于（inti=1；i我不是一个经验丰富的开发人员，所以我的建议可能不是最好的，也不是最有效的

我想创建一个无限循环。在这个循环中，我会放一个switch语句，它检查
intx
的值，该值首先初始化为0

您可以在switch语句之外创建一个细化变量，并将程序的所有后续步骤放在switch语句的后续案例中。在每个案例中，您可以增加或减少细化值，也可以增加或减少switch语句中检查的值（值
x
）。当优化成功时，您更改优化值并增加
x
的值，以便在下一个循环中处理下一个案例。如果优化失败，则减小
x
的值，并在下一个循环中处理上一个案例

我想重复一次，因为我是新手，这可能不是最好的解决方案。如果不是，也许它可以帮助您找到一些新想法。
我尝试解决这个问题，请随意询问是否有任何不清楚的地方。我使用do-while循环来解决您的“返回”问题，并使用一些变量使程序动态

class Tisha {

    // An integer field to store the current level of refinement.
    int level = 0;

    // An array of probabilities for each level of refinement.
    double[] probs = new double[]{
        0.535, 0.335, 0.335, 0.335, 0.335,
        0.335, 0.335, 0.335, 0.285, 0.235,
        0.155, 0.085
    };

    // The random number generator
    Random random = new Random();

    // This function tries to perform a refinement
    public void tryRefinement() {
        if (random.nextDouble() <= probs[level]) {
            level++;
            System.out.println("Refine successful  -  Refine level " + level);
        } else {
            level--;
            if (level >= 0)
                System.out.println("Refine failed  -  Refine level " + level);
            else
                System.out.println("Refine failed  -  Refine reset");
        }
    }

    // The main method
    public static void main(String[] args) throws InterruptedException {

        // Create a 'Tisha' object (are you familiar with OOP?)
        Tisha tisha = new Tisha();

        // Keep refininig until the level reaches 0
        do {
            tisha.tryRefinement();
            Thread.sleep(250);
        } while (tisha.level > 0);
    }
}

Tisha类{
//用于存储当前优化级别的整数字段。
智力水平=0；
//每个细化级别的概率数组。
double[]probs=新的double[]{
0.535, 0.335, 0.335, 0.335, 0.335,
0.335, 0.335, 0.335, 0.285, 0.235,
0.155, 0.085
};
//随机数发生器
随机=新随机（）；
//此函数尝试执行优化
公共无效tryRefinement（）{
if（random.nextDouble（）=0）
System.out.println（“优化失败-优化级别”+级别）；
其他的
System.out.println（“优化失败-优化重置”）；
}
}
//主要方法
公共静态void main（字符串[]args）引发InterruptedException{
//创建一个“Tisha”对象（您熟悉OOP吗？）
Tisha Tisha=新的Tisha（）；
//继续加注，直到液位达到0
做{
tisha.tryRefinement（）；
睡眠（250）；
}而（tisha.level>0）；
}
}
将其存储在变量中并递增，使用
++
和
-
将其递减？我同意ajc。为什么不将您的细化级别存储在变量中，然后根据您的条件递增或递减？这部分起作用，但是，它不会返回到前面的if语句，这意味着百分比为wrong和refinementLevel最终以负值结束。没有办法让Java“返回”到上一个语句。您可以将代码放入循环中，但没有办法实际“返回”到递增和递减的状态，但在失败时不会返回到上一个if语句。但您的问题是：如何获得我的失败后“优化级别”降低1是的，对不起，我只是编辑了一下以更好地澄清我的问题。@Ollieboarder尝试使用
while（true）
围绕
if…else
语句循环，当达到所需的结果时，明显地将其设置为
false
。如果这不起作用，请尝试提出一个新问题，当然要展示你的意图。是的，这就是意图（更难达到更高的层次）.我只是想弄清楚这个代码是如何工作的哈哈，但我认为它是有效的。直接运行的概率是0.00000022。能够继续尝试可以改善这一点，但仍然很糟糕。我知道，目的是让它变得那么难，我正试图在我童年的游戏中模拟一个精炼系统，这同样困难：DIt工作：）非常感谢，我将阅读这篇文章，并试图了解它是如何运作的，这样我就可以为将来学习。
class Tisha {

    // An integer field to store the current level of refinement.
    int level = 0;

    // An array of probabilities for each level of refinement.
    double[] probs = new double[]{
        0.535, 0.335, 0.335, 0.335, 0.335,
        0.335, 0.335, 0.335, 0.285, 0.235,
        0.155, 0.085
    };

    // The random number generator
    Random random = new Random();

    // This function tries to perform a refinement
    public void tryRefinement() {
        if (random.nextDouble() <= probs[level]) {
            level++;
            System.out.println("Refine successful  -  Refine level " + level);
        } else {
            level--;
            if (level >= 0)
                System.out.println("Refine failed  -  Refine level " + level);
            else
                System.out.println("Refine failed  -  Refine reset");
        }
    }

    // The main method
    public static void main(String[] args) throws InterruptedException {

        // Create a 'Tisha' object (are you familiar with OOP?)
        Tisha tisha = new Tisha();

        // Keep refininig until the level reaches 0
        do {
            tisha.tryRefinement();
            Thread.sleep(250);
        } while (tisha.level > 0);
    }
}