Differences

This shows you the differences between two versions of the page.

--- at:tutorial:symbiosis [2007/07/05 09:36] – jdedecker
+++ at:tutorial:symbiosis [2007/07/05 09:57] – jdedecker
@@ Line 57: / Line 57: @@
 If the Java method is overloaded based on arity (i.e. each overloaded method takes a different number of arguments), the number of arguments in the AmbientTalk invocation can be used to identify a unique Java method. Hence, overloading based on arity does not require special attention. If the Java method is overloaded based solely on argument types, the interpreter may derive that the actual arguments can only be converted from AmbientTalk to the appropriate Java types for one of the matching overloaded signatures. Again, if only one match remains, the unique match is invoked. In the remaining case in which the actual AmbientTalk arguments satisfy more than one overloaded method signature, the symbiotic invocation fails. It is then the AmbientTalk programmer's responsibility to provide explicit type information in the method invocation.
-Selection of the correct overloaded method is done using the **cast** method.  In the example below the expression **aVector.remove** returns a closure for the Java method **remove**.  This closure understands the **cast** method which takes a variable argument list.  The arguments supplied to this method are the types of the method that needs to be selected.  In the example below the method **remove**, which is overloaded with the primitive type **int** and the type **Object**, are first selected and then invoked with the argument **0** and the argument **3**.  In the former case the first element in the list will be removed.  In the latter case the object **3** is removed from the vector.
+Selection of the correct overloaded method is done using the **cast** method.  In the example below the expression **aVector.remove** returns a closure for the Java method **remove**.  This closure understands the **cast** method which takes a variable argument list.  The arguments supplied to this method are the types of the method that needs to be selected.  The method **remove** is overloaded with the primitive type **int**, which is the index of the element that needs to be removed, and the type **Object**, which is the element that needs to be removed, in the class Vector.  To invoke the **remove** method that deletes elements based on their index in the vector we first select the method using **remove.cast(jlobby.java.lang.Integer.TYPE)** (note that primitive types are selected by referring to their associated Java class followed by the **TYPE** selector) and then invoke it with the argument **0**.  Similarly, the **remove** method that is overloaded with the type **Object** is selected and then invoked    **3**.  In the former case the first element in the list will be removed.  In the latter case the object **3** is removed from the vector.
 <code>
@@ Line 63: / Line 63: @@
 >><java closure:remove>
 >remove.cast(jlobby.java.lang.Integer.TYPE)(0)
->>
+>>1
 >aVector
->>
+>><java:[2, 3, 4, 5, 6, 7, 8, 9]>
 >remove.cast(jlobby.java.lang.Object)(3)
 >>true
 >aVector
->>
+>><java:[2, 4, 5, 6, 7, 8, 9]>
 </code>
@@ Line 123: / Line 123: @@
 If Java invokes a method declared in an interface with an overloaded method signature, all overloaded invocations are transformed into the same method invocation on the AmbientTalk object. In other words, the AmbientTalk object does not take the types into consideration. However, if the Java method is overloaded based on arity, the AmbientTalk programmer can take this into account in the parameter list of the corresponding AmbientTalk method, by means of a variable-argument list or optional parameters. Otherwise, the Java invocation may fail because of an arity mismatch.
+<code>
+>def test := /.at.tutorial.symbiosis
+>><object:7974034>
+>test.showSymbiosis()
+ping!
+pong!
+>>42
+</code>