Existe uma instrução goto em Java?

Estou confuso sobre isso. A maioria de nós foi informada de que não há nenhuma instrução goto em Java.

Mas descobri que é uma das palavras-chave em Java. Onde isso pode ser usado? Se não pode ser usado, por que foi incluído em Java como uma palavra-chave?

   

A lista de palavras-chave do Java especifica a palavra-chave goto , mas está marcada como “não usada”.

Estava na JVM original (veja a resposta de @VitaliiFedorenko ), mas depois foi removido. Provavelmente, era mantido como uma palavra-chave reservada, caso fosse adicionada a uma versão posterior do Java.

Se goto não estava na lista, e é adicionado à linguagem mais tarde, o código existente que usou a palavra goto como um identificador (nome da variável, nome do método, etc …) seria quebrado. Mas como o goto é uma palavra-chave, esse código nem mesmo será compilado no presente, e ainda é possível fazê-lo realmente fazer algo mais tarde, sem quebrar o código existente.

Para evitar que pessoas sejam mortas por velociraptors.

James Gosling criou a JVM original com suporte a instruções goto , mas removeu esse recurso como desnecessário. A principal razão pela qual goto é desnecessário é que normalmente ele pode ser substituído por instruções mais legíveis (como break/continue ) ou extraindo uma parte do código em um método.

Fonte: James Gosling, session de perguntas e respostas

A palavra-chave existe, mas não está implementada.

A única boa razão para usar goto que eu posso pensar é isso:

 for (int i = 0; i < MAX_I; i++) { for (int j = 0; j < MAX_J; j++) { // do stuff goto outsideloops; // to break out of both loops } } outsideloops: 

Em Java você pode fazer isso assim:

 loops: for (int i = 0; i < MAX_I; i++) { for (int j = 0; j < MAX_J; j++) { // do stuff break loops; } } 

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html

“As palavras-chave const e goto são reservadas, mesmo que não sejam usadas atualmente.”

Assim, eles poderiam ser usados ​​um dia se os designers de linguagem sentissem a necessidade.

Além disso, se os programadores de linguagens que possuem essas palavras-chave (por exemplo, C, C ++) as usarem por engano, o compilador Java poderá fornecer uma mensagem de erro útil.

Ou talvez fosse apenas para parar programadores usando goto 🙂

Eles são reservados para uso futuro (consulte: Palavras-chave da linguagem Java )

As palavras-chave const e goto são reservadas, mesmo que não sejam usadas atualmente.

A razão pela qual não existe uma instrução goto em Java pode ser encontrada em ” The Java Language Environment “:

Java não possui instruções goto. Estudos ilustram que o goto é (mis) usado mais frequentemente do que simplesmente “porque está lá”. Eliminar o goto levou a uma simplificação da linguagem – não há regras sobre os efeitos de um goto no meio de uma instrução for, por exemplo. Estudos sobre aproximadamente 100.000 linhas de código C determinaram que cerca de 90% das declarações goto foram usadas apenas para obter o efeito de quebra de loops nesteds. Como mencionado acima, quebra multi-nível e continue remover a maior parte da necessidade de instruções goto.

Um exemplo de como usar labels “continue” em Java é:

 public class Label { public static void main(String[] args) { int temp = 0; out: // label for (int i = 0; i < 3; ++i) { System.out.println("I am here"); for (int j = 0; j < 20; ++j) { if(temp==0) { System.out.println("j: " + j); if (j == 1) { temp = j; continue out; // goto label "out" } } } } System.out.println("temp = " + temp); } } 

Resultados:

 I am here // i=0 j: 0 j: 1 I am here // i=1 I am here // i=2 temp = 1 

É importante entender que a construção goto é remanescente desde os dias que os programadores programavam em código de máquina e linguagem de assembly. Como essas linguagens são tão básicas (como em, cada instrução faz apenas uma coisa), o stream de controle do programa é feito completamente com instruções goto (mas na linguagem assembly, elas são chamadas de instruções de salto ou ramificação ).

Agora, embora a linguagem C seja razoavelmente de baixo nível, ela pode ser considerada uma linguagem de assembly de alto nível – cada declaração e function em C pode ser facilmente dividida em instruções de linguagem de assembly. Embora C não seja a linguagem principal para programar computadores atualmente, ela ainda é muito usada em aplicativos de baixo nível, como sistemas embarcados. Como a function de C reflete tão bem a function da linguagem de assembly, só faz sentido que goto seja incluído em C.

É claro que o Java é uma evolução do C / C ++. Java compartilha muitos resources de C, mas abstrai muito mais detalhes e, portanto, é simplesmente escrito de forma diferente. Java é uma linguagem de alto nível, então simplesmente não é necessário ter resources de baixo nível como goto quando mais construções de alto nível como funções, para, para cada, e while loops fazem o stream de controle do programa. Imagine se você estivesse em uma function e fizesse um goto para uma etiqueta em outra function. O que aconteceria quando a outra function retornasse? Essa ideia é absurda.

Isso não necessariamente responde por que o Java inclui a instrução goto , mas não permite compilar, mas é importante saber por que o goto foi usado em primeiro lugar, em aplicativos de nível mais baixo e por que não faz sentido. para ser usado em Java.

Não, goto não é usado, mas você pode definir labels e deixar um loop até o label. Você pode usar break ou continue seguido pelo label. Então você pode saltar mais de um nível de loop. Dê uma olhada no tutorial .

Não, felizmente, não há goto em Java.

A palavra chave goto é reservada apenas, mas não usada (o mesmo vale para const ).

Porque não é suportado e por que você quer uma palavra-chave goto que não fez nada ou uma variável chamada goto ?

Embora você possa usar o break label; e continue label; declarações para efetivamente fazer o que goto faz. Mas eu não recomendaria isso.

 public static void main(String [] args) { boolean t = true; first: { second: { third: { System.out.println("Before the break"); if (t) { break second; } System.out.println("Not executed"); } System.out.println("Not executed - end of second block"); } System.out.println("End of third block"); } } 

Não, goto não é usado em Java, apesar de ser uma palavra reservada. O mesmo é verdade para const . Ambos são usados ​​em C ++, que é provavelmente a razão pela qual eles são reservados; a intenção era provavelmente evitar confundir programadores C ++ migrando para Java e, talvez, também manter a opção de usá-los em revisões posteriores de Java.

Como foi apontado, não há goto em Java, mas a palavra-chave foi reservada no caso de Sun ter vontade de adicionar goto a Java um dia. Eles queriam poder adicioná-lo sem quebrar muito código, então reservaram a palavra-chave. Observe que, com o Java 5, eles adicionaram a palavra-chave enum e também não quebraram esse código.

Embora Java não tenha goto , ele possui algumas construções que correspondem a alguns usos de goto , ou seja, ser capaz de break e continue com loops nomeados. Além disso, finally pode ser pensado como um tipo de goto torcido.

Proibir declarações de variables ​​com o mesmo nome.

por exemplo, int i = 0, goto;

É muito considerado uma daquelas coisas que você não faz, mas provavelmente foi listado como uma palavra reservada para evitar confusão para os desenvolvedores.

http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.goto

Se você foi informado de que não há instruções goto em Java, você foi enganado. De fato, Java consiste em duas camadas de código ‘fonte’.

Note que você pode replace a maioria dos usos benignos de goto por

  • Retorna

  • pausa

  • quebrar label

  • jogue dentro tente-catch-finalmente

Veja o link a seguir mostra todas as palavras reservadas do java e informa quais versões foram adicionadas.

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html

goto é reservado, mesmo que não seja usado atualmente, nunca diga nunca no entanto 🙂

Eu também não sou fã de goto , pois geralmente torna o código menos legível. No entanto, acredito que existem exceções a essa regra (especialmente quando se trata de lexers e analisadores!)

É claro que você pode sempre trazer seu programa para o Kleene Normalform traduzindo-o para algo parecido com o de um montador e então escrever algo como

 int line = 1; boolean running = true; while(running) { switch(line++) { case 1: /* line 1 */ break; case 2: /* line 2 */ break; ... case 42: line = 1337; // goto 1337 break; ... default: running = false; break; } } 

(Então você basicamente escreve uma VM que executa seu código binário … onde a line corresponde ao ponteiro da instrução)

Isso é muito mais legível do que o código que usa o goto , não é?

Porque, embora a linguagem Java não a use, o bytecode da JVM faz isso.

Claro que é palavra-chave, mas não é usada no nível do código-fonte.

Mas se você usar jasmin ou outra linguagem de nível inferior, que é transformada em bytecode, então “goto” está lá

goto não está em Java

você tem que usar GOTO Mas não funciona corretamente.em palavras-chave em java não é usado. http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

  public static void main(String[] args) { GOTO me; //code; me: //code; } }