正如所有答案所指出的那样goto-Java中的保留字，并且在语言中不使用。
restart:被称为标识符，后跟冒号。
如果您希望实现similar行为，需要注意以下几点：

outer:                  // Should be placed exactly before the loop
loopingConstructOne  {  // We can have statements before the outer but not inbetween the label and the loop          
    inner:
    loopingConstructTwo {
        continue;       // This goes to the top of loopingConstructTwo and continue.
        break;          // This breaks out of loopingConstructTwo.
        continue outer; // This goes to the outer label and reenters loopingConstructOne.
        break outer;    // This breaks out of the loopingConstructOne.
        continue inner; // This will behave similar to continue.
        break inner;    // This will behave similar to break.
    }
}

我不确定我是否应该说similar，因为我已经说了。

Java keyword list指定了后藤关键字，但它被标记为“未使用”。
这可能是为了防止它被添加到Java的更高版本中。
如果后藤不在列表中，而它后来被添加到语言中，那么使用goto作为标识符（变量名，方法名等）的现有代码将中断。但是因为后藤是一个关键字，所以这样的代码在当前甚至不会编译，并且仍然有可能在以后使它实际上做一些事情，而不破坏现有代码。

如果你向上看，继续，然后中断，他们会接受一个“标签”。尝试一下。后藤本身不会工作。

public class BreakContinueWithLabel {
  
    public static void main(String args[]) {
    
        int[] numbers= new int[]{100,18,21,30};
      
        //Outer loop checks if number is multiple of 2
        OUTER:  //outer label
        for(int i = 0; i<numbers.length; i++){
            if(i % 2 == 0){
                System.out.println("Even number: " + i +
                                   ", continue from OUTER label");
                continue OUTER;
            }
          
            INNER:
            for(int j = 0; j<numbers.length; j++){
                System.out.println("Odd number: " + i +
                                   ", break  from INNER label");
                break INNER;
            }
        }      
    }
}

Read more

Java不支持goto，它被保留为关键字，以防他们想将其添加到更高版本

goto在Java中不做任何事情。

Java也不使用行号，这是后藤函数所必需的。与C/C++不同，Java没有后藤语句，但Java支持标签。标签在Java中唯一有用的地方是嵌套循环语句之前。我们可以用break来指定标签名称，以打破特定的外部循环。

在Java世界中没有“后藤”。主要原因是开发人员意识到，使用后藤的复杂代码会导致代码变得非常可怜，并且几乎不可能增强或维护代码。
然而，这段代码可以修改一点，并使用continue和break的概念，我们可以使代码工作。

import java.util.*;

public class Factorial 
{
    public static void main(String[] args) 
    {
        int x = 1;
        int factValue = 1;
        Scanner userInput = new Scanner(System.in);
        restart: while(true){
        System.out.println("Please enter a nonzero, nonnegative value to be factorialized.");
        int factInput = userInput.nextInt();

        while(factInput<=0)
        {
            System.out.println("Enter a nonzero, nonnegative value to be factorialized.");
            factInput = userInput.nextInt();
        }

        if(x<1)//This is another way of doing what the above while loop does, I just wanted to have some fun.
        {
            System.out.println("The number you entered is not valid. Please try again.");
            continue restart;
        }
        while(x<=factInput)
        {
            factValue*=x;
            x++;
        }
        System.out.println(factInput+"! = "+factValue);
        userInput.close();
        break restart;
}
    }
}

goto是语言中未使用的保留字。所以没有goto。但是，如果你想要荒诞派戏剧，你可以哄骗一个标签的语言特征。但是，与其标记for循环（这有时很有用），不如标记代码块。你可以在这个代码块中，在标签上调用break，把你吐到代码块的末尾，这基本上是一个后藤，它只在代码中向前跳。

System.out.println("1");
    System.out.println("2");
    System.out.println("3");
    my_goto:
    {
        System.out.println("4");
        System.out.println("5");
        if (true) break my_goto;
        System.out.println("6");
    } //goto end location.
    System.out.println("7");
    System.out.println("8");

这将打印1、2、3、4、5、7、8。当中断时，代码块跳到代码块的后面。您可以移动my_goto: {、if (true) break my_goto;和} //goto end location.语句。重要的是break必须在标记的代码块内。
这比真实的的后藤还要丑。从来没有真正做到这一点。
但是，有时使用标签和break是有用的，而且知道如果你在break时标记代码块而不是循环，你会向前跳，这实际上是有用的。因此，如果你在循环中中断代码块，你不仅中止了循环，而且跳过了循环结束和代码块之间的代码。