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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
4 R% s# l! C, t  U
2 _1 q0 b4 Z4 D, l1 n public Object buildActions () {
    super.buildActions();
   
8 U% q; Z( A  ?- b    // 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
3 o3 l, \# I9 R7 l: W    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
# k# j( b+ g# \" |, P    // 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
% I: I  Q2 i0 g0 o4 @% S    // changes the heatbugs have made. The ordering here is
0 Y* W( [6 d4 i2 a8 q, \    // significant!
        
! u5 E$ d& d4 i3 }/ `9 M6 ?& ^    // Note also, that with the additional
$ i/ U5 b7 p  s    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
- F/ {' `  t# f( O8 r$ p7 P) s    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
! u# v2 l' u# @' P+ ]" w        
0 x' v; _+ B' u! S' x0 [/ B. [1 S- p6 R    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
9 j" ]1 [1 G+ f9 b$ E    // order of iteration through the `heatbugList' will be
9 N( K8 d& ^5 j( }$ Z5 k: [1 c    // identical (assuming the list order is not changed
    // indirectly by some other process).
) Y/ k8 @9 L5 P# L( e- w$ E   
    modelActions = new ActionGroupImpl (getZone ());

) t% K+ I8 ~3 F, b; i) \2 X* @    try {
" c; D/ P" o+ m. _- X( L1 p. i      modelActions.createActionTo$message
  }/ e* o" n0 A- G8 F6 v4 n        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
- k  g1 E0 I& O0 n- X6 C$ t" b& W  Z      System.err.println ("Exception stepRule: " + e.getMessage ());
2 ]  b, K1 ^* ?  l9 a' [8 }$ v0 Z    }

7 V5 s! D* V) N8 ^! t    try {
' F% ]7 C4 P- m5 o% K. p" H0 i      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
( y$ T6 U9 b8 S9 [1 W        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
) c4 Z* W8 d  \" n$ I% N/ L& Y3 h        modelActions.createFActionForEachHomogeneous$call
8 {: u. O0 h& Y        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
9 @& K( h: G* Y9 N7 B1 o  a) D      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();
9 |- F6 T& ^  z* f- E3 x( y
1 o3 \3 X5 j8 O) ?" E; T: n    try {
      modelActions.createActionTo$message
. _6 ^5 Q4 Y7 a6 V/ ~        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
: J; m6 v* d% |4 G: s) X( S      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
    // Then we create a schedule that executes the
    // 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
    // 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
3 z* v, S; M/ y0 T4 @    // the beginning of the loop.
" w4 Z0 W  H* q6 z* l/ E
! {; B5 G) v  H) j    // This is a simple schedule, with only one action that is
  U: |! z8 Z) G    // just repeated every time. See jmousetrap for more
4 O) Z# n; b5 T    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
5 F9 M# B! i( O( J$ t    modelSchedule.at$createAction (0, modelActions);
0 X3 T* O7 b2 Q% q9 T" g        
1 c; J+ z4 `5 `/ o    return this;
  }