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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
" ^4 S6 Z- q7 t  S8 {+ a
public Object buildActions () {
2 U2 M; ~% _6 r& Q- P8 J    super.buildActions();
   
1 J* \- E6 y0 W    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
5 y( M# u9 k& m) [" A1 l4 }    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
' }# i, k& V& x% m    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
        
8 w& E5 ^% P/ K, g- K    // Note we update the heatspace in two phases: first run
1 D0 ^; @; V: @1 g$ b  T    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
; f( b+ Q0 K( _" u0 S0 E! i    // significant!
. E) ]8 }% U$ e* B        
- M* A, M2 H9 h    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
! h3 ^" T, T* i  P" e  A4 N  J    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
2 J/ z3 t" l; {. ~    // By default, all `createActionForEach' modelActions have
' _* K9 E9 O8 ^: H; R    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
3 L5 S! e1 V/ z7 d# Y$ h, ?7 {  |    // indirectly by some other process).
" K! \+ r) k: U; H& {   
5 ]) ~3 |4 v, O    modelActions = new ActionGroupImpl (getZone ());

    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
# C9 f! \' ~0 Y* W$ F# B2 K    }

    try {
; `% j8 d! \2 i8 o! A- P1 P3 Z9 P      Heatbug proto = (Heatbug) heatbugList.get (0);
1 r& W$ |0 z0 e$ g( X# c0 ^      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
1 Q9 w3 x  X$ w% ?$ \      actionForEach =
2 g  K% t3 Z" c9 {4 J5 R6 V# y        modelActions.createFActionForEachHomogeneous$call
4 j: c8 m0 i8 q. x        (heatbugList,
         new FCallImpl (this, proto, sel,
+ }: `4 a! |% W: ^* ^' U                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
1 l; S2 K3 C* T0 m    }
   
; d& A; r5 T  F6 y# A$ q  g3 k8 v    syncUpdateOrder ();

    try {
1 w/ x% o: u/ U) m, y7 Q, i      modelActions.createActionTo$message
; P# r& g! J& k        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
! ?. y2 E5 r  z4 e) S) Y  X; t    }
        
    // Then we create a schedule that executes the
- o0 m1 `) G0 O7 Q% }' n- s6 B" p    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
/ k) l! O$ U. r2 b5 A! T, M    // time, we create a Schedule that says to use the
    // modelActions ActionGroup at particular times.  This
, G, a/ J! z( S1 e6 }  V    // schedule has a repeat interval of 1, it will loop every
, \8 }3 }3 y; L1 o5 r4 l    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.

, h& X7 M& X& A* H1 g    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
/ M  p7 |4 C# d7 O4 H  r3 k  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
    return this;
- ?# ~$ c" l$ F. @  }