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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
% E. O, {1 W- z- t, B: |
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
    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
$ t7 D- F6 w  z- j$ @+ N    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
8 e) {  P" J. E        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
, B  Y$ f6 s. ]/ C8 f/ ]; z        
3 Q2 K2 R. J8 E    // Note also, that with the additional
    // `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
5 ~: k4 j4 S6 ?' K+ \) e+ e    // list from timestep to timestep
( o6 F5 K) D2 a        
# t  W1 E$ t! k7 k" _( N" e    // By default, all `createActionForEach' modelActions have
    // 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
8 n! t8 z+ v% {    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());

    try {
  F+ K) W0 p3 O- ~      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
4 U! G- Y, x+ R1 M1 O" {
0 H" H0 v$ l* K) P7 |  y+ F5 L    try {
3 }! E1 u0 H: x, ~+ X6 s6 P      Heatbug proto = (Heatbug) heatbugList.get (0);
% a3 e- d* w$ V1 ?% Y      Selector sel =
  b5 N/ G' g% r# R        new Selector (proto.getClass (), "heatbugStep", false);
$ L* t) @1 d3 S4 Z      actionForEach =
$ G' r% t. I; ]- f        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
2 j! ^$ ^! K$ \6 b( D  A8 r7 b         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
: J/ W2 K- Z. ^3 v$ h% d9 |: \) ~    }
   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
+ i! z4 }; u+ g+ Q6 }  X4 C    } catch (Exception e) {
4 X8 Q  m/ K. N) ?2 D6 V6 U      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
+ ?0 x" ?+ \5 v4 i& [7 M        
5 B2 \! Q) F$ e& S4 l( ]- A1 e    // Then we create a schedule that executes the
, f% ~$ x3 B. }' ?6 P    // modelActions. modelActions is an ActionGroup, by itself it
) k3 N" _, V5 [# j- J" p2 p    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
0 B! J# v% o( ]1 a/ i) E    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
8 P* R- I4 d. V: {  P% V    // time step.  The action is executed at time 0 relative to
/ l: s- v9 ?$ Z    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
# f) a6 a1 y3 k/ E6 [+ F: t    // just repeated every time. See jmousetrap for more
    // complicated schedules.
9 z% N! n: ~  B% e  {4 }7 r  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
0 T* s+ ^. ^# p6 Q: ^        
    return this;
  }