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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
3 \4 p: M, Z8 x( h- _
( y$ o2 d' R8 g* f+ s) R6 a0 P1 W public Object buildActions () {
0 S/ `7 w7 _* e, O/ u+ h& F* z1 A    super.buildActions();
   
( M6 l! {1 h1 s6 f+ u    // Create the list of simulation actions. We put these in
* H! W* R9 @, u' ^    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
; r1 b# t: x- Q+ c    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
- t0 L+ V/ n( a; e' [8 x    // changes the heatbugs have made. The ordering here is
    // significant!
        
    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
3 C; F. C7 Z9 m    // 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
    // list from timestep to timestep
        
1 ~3 B4 J$ n9 Z) ?$ ]; g' K7 {    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
/ [, }! ?5 G+ T. R1 y    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
) _# N6 s. V% A1 t( L& }4 N    // indirectly by some other process).
: g  H6 l9 w' k. x8 {   
    modelActions = new ActionGroupImpl (getZone ());

    try {
      modelActions.createActionTo$message
" }2 z" d  n! N8 {; d        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
1 W" {8 P# @8 R3 h' `5 Z6 \7 l% j      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
9 w# v' z3 ~. |' G" \9 @+ c) V3 ]$ R      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
% L4 Y2 D) k3 `6 m9 `      actionForEach =
7 P- f) N7 m3 @7 ^        modelActions.createFActionForEachHomogeneous$call
5 Z6 D2 E3 g" b9 n  c        (heatbugList,
: p; \5 i" ^$ _1 }- m0 J" ~         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
8 S; v2 d3 L  z5 p3 y0 X9 D$ p: _      e.printStackTrace (System.err);
    }
1 }- \) K2 w* }, b, c   
    syncUpdateOrder ();
: I8 [5 D$ p' `4 U" B" ~; n
3 ^; s' T1 A0 N    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
* r* x5 q! `$ L& L; N      System.err.println("Exception updateLattice: " + e.getMessage ());
, I/ Q/ f* y8 q# m! H  r: K    }
        
    // Then we create a schedule that executes the
9 o1 Y% U9 K4 C* T8 W    // 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
6 `( H1 A7 H" F8 w! x8 `6 [    // modelActions ActionGroup at particular times.  This
  j. }# Y8 p+ k' D/ Q; d    // schedule has a repeat interval of 1, it will loop every
% r/ z# a, |  M    // time step.  The action is executed at time 0 relative to
" x; u7 u, d" y* \0 a1 u: j) {    // the beginning of the loop.

, V7 X  b5 m0 j# M$ W    // This is a simple schedule, with only one action that is
# E. \& `7 d3 |! W6 Y0 [) W) c" j    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
# v5 I  |: a! x4 }    modelSchedule = new ScheduleImpl (getZone (), 1);
$ v8 z+ c8 j  N" y% a) x% b    modelSchedule.at$createAction (0, modelActions);
) }; C/ k" X! |, I' s  O6 W        
5 @2 m$ {5 C4 m- g2 d    return this;
* X% v- A' Y% g+ |2 W* H  }