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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：

! e0 C# }3 [% y$ Y: `( R, A public Object buildActions () {
; T% O9 m% \0 U2 Q5 y# {    super.buildActions();
4 d. S# J+ K' ^2 N  o( s0 A- Z   
( M$ F9 c1 s& P  L9 o    // Create the list of simulation actions. We put these in
' W$ e/ F8 `* \  P    // 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
' t$ o0 C8 n4 a; U    // object, or ForEach object in a collection.
1 b) k; I" l) d9 j( Q1 Y) P8 u& C        
    // Note we update the heatspace in two phases: first run
, [5 y3 X4 f- R    // diffusion, then run "updateWorld" to actually enact the
/ Y* j/ r: ~" B; T1 z    // changes the heatbugs have made. The ordering here is
    // significant!
        
: r; n6 Q- ]! `7 p5 C. y    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
/ b0 g/ W% g: P# U    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
; ~- j; D0 C0 q' H8 V9 h' q. z        
    // 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
    // indirectly by some other process).
" _! O+ o: A8 Z/ P4 c! K1 L   
. @8 G& u3 `; Z( Y    modelActions = new ActionGroupImpl (getZone ());
) l' i) s- u6 `2 k3 a
' d3 @% c1 b7 V' T, b! m: \; k    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

7 z: L! S1 V' q) p- k    try {
1 b) ^/ v  y. t% h; v& A  }      Heatbug proto = (Heatbug) heatbugList.get (0);
% Q& U5 Z! P. L0 U( v+ [      Selector sel =
$ @& Z" u3 J* s        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
. {# S, y/ S( d1 _        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
) T3 Y6 W0 z" E8 m% R         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
4 h& C1 x9 }8 o* m' b: s. N    }
+ T/ [& o" N  `( U3 v' w% }   
    syncUpdateOrder ();
2 _* T9 ~: m8 H8 w
    try {
      modelActions.createActionTo$message
( ]. O2 U& X! T7 t3 w8 F3 @) \        (heat, new Selector (heat.getClass (), "updateLattice", false));
/ h8 W. m, N! E; c% y) v* }& P    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
$ b! e6 M* N) _% n8 S, e: G& B/ K, e        
" [% G0 s3 y5 t7 ?# T    // 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
2 G& U: X- S3 Z    // modelActions ActionGroup at particular times.  This
% }3 S( g0 e7 O# Y    // schedule has a repeat interval of 1, it will loop every
0 M* G/ J1 F1 r! k% ]: L    // time step.  The action is executed at time 0 relative to
! `  ^; g3 A+ G: Q    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
+ L8 M+ y6 i1 Y  
  @3 X3 o5 R  Z    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
    return this;
  }