问jheatbugs-2001-03-28中某些代码

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
% {, y5 w: p  X  o! l$ k$ t
public Object buildActions () {
    super.buildActions();
   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
' o# v' o/ c/ R( z    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
8 T. Y& F- F, e    // called <foo>". You can send a message To a particular
2 N( R7 o" b3 u2 R! d+ m    // object, or ForEach object in a collection.
" H, I  X/ e5 t: u" z$ Q        
    // Note we update the heatspace in two phases: first run
. {5 h! R) |1 s  P  n. b    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
9 f5 |5 M) ?$ U8 o' a; @, _  J5 t  Y        
: Q8 X) |3 Z. h# K& ]    // Note also, that with the additional
, I3 M2 |5 i* }# m/ f    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
' H$ {0 V* ~7 H0 o$ r    // list from timestep to timestep
) M9 n6 i! _+ O8 |  r& k9 z# [# ?        
    // By default, all `createActionForEach' modelActions have
7 a8 F4 J- i) `! Q' K9 ^* Z2 P    // a default order of `Sequential', which means that the
' X7 ^" @; ~0 J0 u. ~! G, _    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
) x1 Y) `6 x$ P' p    // indirectly by some other process).
5 m8 J8 K( Y/ {   
  M. `1 I6 `- ~    modelActions = new ActionGroupImpl (getZone ());
' b! i0 X! t2 {+ M* k3 `
    try {
, {# O+ S$ v1 }- G5 c2 b( Y/ b      modelActions.createActionTo$message
- B; q- ?- x2 \6 U- k        (heat, new Selector (heat.getClass (), "stepRule", false));
/ I1 c' N( W! h% r    } catch (Exception e) {
; `. [0 n* G* D/ K+ q! m      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

6 ^. E& D" h3 o7 n: {# e/ [    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
# {: q8 H3 S( Z+ }7 f      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
0 c" C  w( m& c/ _2 m6 X" u         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
& m; T0 k/ a2 _+ }. P/ w/ j+ t9 t    } catch (Exception e) {
      e.printStackTrace (System.err);
4 ]6 R  P$ S% v    }
/ x# s$ `- Z" w8 y! Z   
& J9 n& h; x$ a% I7 m! [8 n3 W    syncUpdateOrder ();

& |! l7 v/ y" ?1 S5 T% M1 P! O    try {
      modelActions.createActionTo$message
1 G4 T: ~: \4 r) v& u1 L        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
% k0 p3 |9 }! v; ~8 w5 y; Y) R5 d    // Then we create a schedule that executes the
7 w# C" T0 K4 g( Y$ B) n( D    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
# r4 I- J8 R' }% e    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
/ N* @! d' {% e7 ^8 |# f& o, {
    // This is a simple schedule, with only one action that is
$ O) D' \! s; O0 B0 ?% [8 N    // just repeated every time. See jmousetrap for more
    // complicated schedules.
( y: o- @2 ?5 O' s  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
1 d1 e" q% D9 e! @8 y+ `        
    return this;
; I" i0 b6 t* X- W- k. k  }