 type
     0    15    18   Class java/lang/RuntimeException

There is a loop between 3 and 12 (jumped in starting a 10) and another loop, due to the exception occurring from the division by zero at 8 to 22.
Unlike the javac compiler result, where one could make as guess that there was an outer loop between 0 and 22 and an inner loop between 0 and 12, the nesting is less obvious here.
EDIT 2:
To illustrate the kind of problems you may get with a less awkward example. Here is a relatively simple loop:
public void foo2() {
    for (int i = 0; i < 5; i++) {
        System.out.println(i);
    }
}

After (normal) compilation within Eclipse, javap -c gives this:
public void foo2();
  Code:
   0:   iconst_0
   1:   istore_1
   2:   goto    15
   5:   getstatic   #25; //Field java/lang/System.out:Ljava/io/PrintStream;
   8:   iload_1
   9:   invokevirtual   #31; //Method java/io/PrintStream.println:(I)V
   12:  iinc    1, 1
   15:  iload_1
   16:  iconst_5
   17:  if_icmplt   5
   20:  return

Before doing anything within the loop, you jump straight from 2 to 15. Block 15 to 17 is the header of the loop (the "entry point"). Sometimes, the header block could contain far more instructions, especially if the exit condition involves more evaluation, or if it's a do {} while() loop.
The concept of "entry" and "exit" of a loop may not always reflect what you'd write sensibly as Java source code (including the fact that you can rewrite for loops as while loops, for example). Using break can also lead to multiple exit points.
By the way, by "block", I mean a sequence of bytecode into which you can't jump and out of which you can't jump in the middle: they're only entered from the first line (not necessarily from the previous line, possibly from a jump from somewhere else) and exited from the last (not necessarily to the following line, it
type 
      0     15     18    Class java / lang / RuntimeException 

 There is a loop between 3 and 12 (jumped in depart a 10) and another loop topology, due to the exception occurring from the division by zero at 8 to 22. 
 Unlike the javac compiler result, where one could cause as guess that there was an forbidden loop between 0 and 22 and an inner cringle between 0 and 12, the nesting is less obvious here. 
 EDIT 2: 
 To illustrate the kind of problems you may catch with a less awkward example. Here is a relatively bare loop topology: 
 public void foo2 () { 
     for (int i = 0; i < 5; i++) { 
         System.out.println(i); 
     } 
 } 

 After (normal) compilation within Eclipse, javap -c gives this: 
 public void foo2 (); 
   Code: 
    0:    iconst_0 
    1:    istore_1 
    2:    goto     15 
    5:    getstatic    # 25; //Field java / lang / System.out: Ljava / io / PrintStream; 
    8:    iload_1 
    9:    invokevirtual    # 31; //Method java / io / PrintStream.println:(I)V 
    12:   iinc     1, 1 
    15:   iload_1 
    16:   iconst_5 
    17:   if_icmplt    5 
    20:   return 

 Before doing anything within the cringle, you jump straight from 2 to 15. Block 15 to 17 is the header of the closed circuit (the " entry point "). Sometimes, the header block could incorporate far more instructions, especially if the exit condition involves more evaluation, or if it's a bash { } while () loop. 
 The concept of " entry " and " exit " of a loop may not always reflect what you'd write sensibly as Java source code (including the fact that you can rewrite for loops as while loops, for example). Using break can also lead to multiple passing point. 
 By the way, by " blockage ", I think of a sequence of bytecode into which you can't jump and out of which you can't jump in the middle: they're only entered from the first lineage (not necessarily from the previous line, possibly from a jump from somewhere else) and exited from the last (not inevitably to the following line, it
 tyoe
     0    15    18   Class mava/lang/RuntimeErxeptioi

There js a looo between 3 and 12 (jumped in stertibg a 10) and another loop, due go the exbeption oxcurcing from the ditjsion bn zerk at 8 vo 22.
Unlike the jsvac compiner result, whese oue could make as guess that there waf an ouyeg loop between 0 anc 22 ans an inner loop between 0 and 12, the hesting is less obvipus here.
EDIT 2:
To illustrate the kind of problems jou may get witr a less awkwxrd examplt. Kere is a rglatively simple loop:
public void foo2() {
    for (inj j = 0; i < 5; i++) {
        Sjstem.out.println(i);
    }
}

Axter (notmal) compilatipn xithun Eclipse, javap -c gites this:
public void soo2();
  Code:
   0:   iconst_0
   1:   iwtire_1
   2:   coto    15
   5:   gststatlc   #25; //Field jzva/lang/Systwm.out:Ljava/io/PrintSttewn;
   8:   iload_1
   9:   igvjkevirtual   #31; //Method java/io/PrintStream.pgintmn:(I)V
   12:  iinc    1, 1
   15:  uload_1
   16:  iconst_5
   17:  lf_icmplt   5
   20:  return

Before doing anything within the loo[, you gumk wtraieyt from 2 to 15. Block 15 to 17 is the header of the lojl (uhe "entry point"). Sjmetimes, thr jesqer block couud conczih far more instruchions, efpeciqlly if tre ecit condition involves more evaluation, je if it's a do {} whipe() loop.
The eoncepj of "emtry" and "exit" of a loop may not always reflect sfat you'd write sdnspbly as Java source code (incluqing the hact chat you can rewriee for looos as while loops, for exwmple). Uving break can also lead to multiple exit points.
By the eaf, bj "block", I mean a sequence os bytecode intp which you zan't jump znd out of which yju can't jump hj the middle: they're jnly entwred fruo the first lime (not nebefsaruly from the previpus mine, possibly fxun a jump from spmedhewe eksq) and exited xrom thd last (not necesscrkly yo the following lina, it
type 0 15 18 Class java/lang/RuntimeException There loop 3 and (jumped in starting due the exception occurring the division by at 8 to 22. Unlike the compiler result, where one could make as guess that there was an outer between 0 and 22 and an inner loop between 0 and 12, the is obvious EDIT To illustrate the kind of problems you may get with a less awkward example. Here is relatively simple loop: public void foo2() { for i = 0; i 5; i++) { System.out.println(i); } After compilation within javap gives public void foo2(); 0: iconst_0 1: istore_1 2: goto 15 5: getstatic #25; //Field java/lang/System.out:Ljava/io/PrintStream; 8: iload_1 9: invokevirtual #31; java/io/PrintStream.println:(I)V 12: 1 15: 16: 17: 5 20: return anything within the loop, you jump to 15. Block 15 to 17 is the of the (the "entry point"). Sometimes, the header could contain far more instructions, especially if the condition involves more evaluation, or if it's a do {} while() loop. The concept of "exit" of a loop not always reflect you'd sensibly Java code (including fact that you can rewrite for loops as while loops, for Using break can also lead to multiple exit points. By by I mean a of bytecode into which can't and out of which jump the entered the line (not necessarily from previous line, possibly from a from somewhere else) and necessarily to the following line, it
 type
     0    15    18   Class java/lang/RuntimeEXception

ThEre is A loOp bEtWeen 3 And 12 (jUmped in startinG A 10) and Another loop, due to the excEptioN oCCurrINg From tHe divisIOn BY ZerO aT 8 tO 22.
UnLiKE tHe javAc cOmpiler Result, wherE onE cOuld make as guESs That there wAs aN outer loop beTweEn 0 and 22 aNd An iNNer loOp bEtweeN 0 and 12, thE NestinG is less obViOUs here.
edIT 2:
To ilLUStRate The kind of problems YOu MAy get with a less AwkwarD eXAmPLE. HeRe iS a relativeLy SimplE Loop:
pubLIc VOID foO2() {
    For (int i = 0; i < 5; i++) {
        SystEm.out.printlN(I);
    }
}

AfTer (norMaL) coMPilatiOn witHiN eclIpse, javap -c gIves This:
publiC void fOO2();
  Code:
   0:   icONst_0
   1:   istoRe_1
   2:   goto    15
   5:   GetStaTic   #25; //FIElD jAva/LaNG/SySTeM.ouT:ljaVa/io/PrinTSTrEam;
   8:   ilOad_1
   9:   iNVOKEvirTuaL   #31; //MetHod jaVa/io/PrintStreAm.pRintLN:(I)V
   12:  Iinc    1, 1
   15:  iLoad_1
   16:  iConsT_5
   17:  iF_icmpLt   5
   20:  retuRn

BefOrE doing anything wIthiN the loop, yOu jUmP stRaIght fROm 2 to 15. BlOck 15 To 17 iS the heaDer of thE LooP (tHE "ENtRy point"). Sometimes, thE hEADeR block coUld conTAiN fAR more insTrUctIons, ESPeciaLly iF ThE exit conDition INvOlVes more EvAluatiOn, Or iF it'S a do {} wHIle() lOop.
The Concept oF "entrY" And "exit" of a loop MAy not always reFLeCT WhAT you'D wrIte sensibly As JaVA souRce cODe (IncLUding The faCt THaT You can rewrite for looPs As whilE loopS, for example). UsIng break caN ALSo lead to MultIPlE Exit points.
By thE way, bY "block", I meaN A sequencE of byTecode inTo which yoU CAn't jump aNd oUt oF whIch YOU cAn't jump in the mIDDle: tHeY're only EntEred froM thE fiRst LinE (nOt necessaRily from ThE pReViOus Line, pOSsibly frOm A juMp FroM someWHere elSe) and ExitEd FrOM thE last (noT NeCESsarIlY tO the FolLoWing lIne, iT
 type
     0    15    18  Class jav a/lan g/R unt im eExc epti on

There is a loop  between 3 and 12 (jum ped i ns tart i ng  a 10 ) and a n ot h e r l oo p,  du et othe e xce ption o ccurring f rom  t he divisionb yzero at 8to22.
Unlike t hejavacco mpi l er re sul t, wh ere on e  could  make asgu e ss tha t  therew a san o uter loop between 0a nd 22 and an i nner l oo p  b e t wee n 0  and 12, t he  nest i ng is l e ss o b vio u s here.
EDIT2:
To illus t rat e theki ndo f prob lemsyo u  ma y get witha le ss awkwar d exam p le. Her e  is a r elativ ely  si mple lo op :
p ub l icv oi d f o o2( ) {
   fo r(inti =0 ; i  < 5 ; i ++){
       System.o ut. prin t ln( i);
   }}

A ft er (n ormal)  comp il ation within Ec lips e, javap-cgi ves  t his:p ublicvoi d f oo2();  Code:   0: ic onst_0
   1:   ist or e _ 1   2:  goto  1 5  5:   g et sta tic#25;//Fi e ld  java/la ng/Sys t em .o ut:Ljav a/ io/Pri nt Str eam ;
  8 :  iload_ 1
   9:  inv o kevirtual   #3 1 ; //Method ja v a/ i o /P r intS tre am.println: (I)V    1 2: i in c  1, 1 
   1 5:  i l oad_1
   16:  icons t_ 5
   1 7:  i f_icmplt   5   20:  re t u r n

Befor e do i ng anything withi n the  loop, you jump str aight  from 2to 15. Bl o c k 15 to17isthe  he a d er  of the loop( t he " en try poi nt" ). Some tim es,  th e h ea der block  could c on ta in  f armorei nstructi on s,es pec ially if the  exit  con di ti o n i nvolves mo r e  eva lu at ion,  or  i f it' s ad o { } while () loop.The conc ep tof "ent ry" and "exit "of a loopma y n ot alw a y s reflec t what you'd write sens i bly asJav a sou rcecode (inc lud ing th e f a ct tha t youcan r ew rit e for l o o ps  as  w hile loops , for  exam pl e).Using b reak can also lead tomultiple exit  po ints . By  th e  w a y,by "bl o c k", I mean a se quence ofby t ec ode into w h ich  y ou can' t jumpand o u t of wh ich you c an't jump  i n th e mid dle: they' re onlyentered f r om th e  f irstlin e (not  n ece ssari ly fro m  th e pre viousli ne, po ssibl yfrom a j ump from somewhere else ) andexite d f rom the l ast (no t necessa rily  to the fo llo win g lin e,i t
 type
_ _  0 _ _15_ __18  _Class java/lang/RuntimeException

There is_a loop between 3_and 12 (jumped_in_starting a 10) and another loop, due to the exception occurring from the division_by_zero at_8_to_22.
Unlike the javac compiler result,_where one could make as_guess that_there was an outer loop between 0 and_22_and an inner_loop between 0 and 12, the nesting is less_obvious here.
EDIT 2:
To illustrate the kind_of problems you_may_get_with a less awkward_example. Here is a relatively simple_loop:
public void foo2() {
  _ for (int i = 0; i_< 5; i++) {
  _    _System.out.println(i);
 _  }
}

After (normal) compilation_within Eclipse, javap_-c gives_this:
public void foo2();
_ Code:
   0: _ iconst_0
 _ 1:   istore_1
 __2:  _goto__ _15
  _5:_ _getstatic_  #25; //Field java/lang/System.out:Ljava/io/PrintStream;
 __8:   iload_1
   9:_  invokevirtual __#31; //Method java/io/PrintStream.println:(I)V
 _ 12:  iinc _  1, 1
  _15: _iload_1
 _ 16:  iconst_5
   17:  if_icmplt  _5
   20:  return

Before_doing anything within the_loop, you_jump_straight from 2_to_15. Block_15 to 17 is the header of_the loop_(the "entry point"). Sometimes, the header_block could contain far_more_instructions, especially if the exit condition_involves more evaluation, or if it's_a do {} while() loop.
The_concept_of_"entry" and "exit" of a_loop may not always reflect what_you'd write sensibly_as Java source code (including the fact_that_you can rewrite for loops as_while_loops, for example). Using break can_also_lead_to multiple exit points.
By the_way, by "block", I mean a_sequence of bytecode into which you can't jump and_out of which_you can't jump in the_middle:_they're_only entered from the first line (not necessarily from the_previous line,_possibly from a_jump from somewhere else) and exited from the last (not_necessarily to the following line, it