§4.7 Callin binding with static methods

The normal case of callin bindings refers to non-static methods on both sides (base and role). Furthermore, in Java inner classes can not define static methods. Both restrictions are relaxed by the following rules:

(a) Static role methods

A role class may define static methods (see also §1.2.1.(f)).

(b) Binding static to static

A callin binding may bind a static role method to one or more static base methods. It is, however, an error to bind a static base method to a non-static role method, because such binding would require to lift a base object that is not provided.

(c) before/after

In addition to the above, before and after callin bindings may also bind a static role method to non-static base methods.

(d) replace

In contrast to §4.7.(c) above, a replace callin binding cannot bind a static role method to a non-static base method.

The following table summarizes the combinations defined above:

<-   base method
static non-static
role
method
static OK before/after: OK
replace: illegal
non-static illegal OK

(e) No overriding

Since static methods are not dynamically bound, overriding does not apply in the normal semantics. Regarding callin bindings this has the following consequences (assuming a role RMid played by BMid plus its super-class BSuper and its sub-class BSub.

  1. If a static base method BMid.m is bound by a callin binding this has no effect on any method m in BSub.
  2. If a callin binding mentions a method m which is not present in BMid but resolves to a static method in BSuper the binding only affects invocations as BMid.m() but not BSuper.m(). If the latter call should be affected, too, the callin binding must appear in a role class bound to BSuper, not BMid.
  3. In order to bind two static base methods with equal signatures, one being defined in a sub-class of the other one, two roles have to be defined where one role refines the playedBy clause of the other role (say: public class RSub extends RMid playedBy BSub). Now each role may bind to the static base method accessible in its direct base-class.