Frage zu Autoboxing

[Gast]

Gibt es genau festgelegte Spezifikationen/Strategien, wie z.B. folgende Anweisungen bearbeitet werden, und wie sieht es mit der Abwärtskompatibilität aus?
* Existierende Methode:
- foo(int x)
- foo(Integer y)
* Aufruf dann mit: foo(1), foo(i) oder foo(i+1)

oder

* Existierende Methode:
- foo (Integer x, int y)
- foo (int x, Integer y)
* Aufruf dann mit: foo(3,7)

 

[bygones]

es gibt einen algorithmus zum finden der passenden methode - im allgemeine gesagt werden die überladenden Methoden nach spezifität geordnet, wobei primitive Typen als genereller angesehen werden als Objekttypen. Als aufgerufenen Methode wird die generellste Methode, die auf die Parameter matcht genommen.

D.h. im ersten Fall müsste die int methode aufgerufen werden. Wie java sich aber im zweiten Fall verhält weiß ich leider nicht.... also einfach mal ausprobieren

 

[schmeckzilla]

...
* Existierende Methode:
- foo(int x)
- foo(Integer y)
* Aufruf dann mit: foo(1), foo(i) oder foo(i+1)
...

Heißt das, Du hast zwei Methoden mit unterschiedlichen Parametern definiert?

Autoboxing und Unboxing ist für mich, dass Java ab JDK 1.5 automatisch zwischen primitiven Variablen und ihren dazugehörigen WrapperObjekten wechselt.

Autoboxing:

int i = 27;

Integer myInt = i;  // autobox!
Integer myInt2 = new Integer(i);  // manuelles Wrappen

Unboxing:

Double dObj = 27.0;  // with autoboxing :-)
double d = dObj;       // unbox!
double d2 = dObj.doubleValue();  // manuelles Entwrappen

Java fügt für Dich automatisch die ensprechende Variante ein.

public class AutoBoxTestDrive {
        
    public static void main (String[] args) {
        int i = 13;
        Integer iObj = i;
        
        testeBox(i);
        testeBox(iObj);
        testeBox2(iObj);
        testeBox3(i);
    }
    public static void testeBox (int i) {
        System.out.println("Bin mit int aufgerufen worden!");
    }
    
    public static void testeBox (Integer iObj) {
        System.out.println("Bin mit Integer aufgerufen worden!");
    }
    
    public static void testeBox2 (int i) {
        System.out.println("iObj wurde unboxed!");
    }
    
    public static void testeBox3 (Integer iObj) {
        System.out.println("i wurde autoboxed!");
    }
}

Output:
Bin mit int aufgerufen worden!
Bin mit Integer aufgerufen worden!
iObj wurde unboxed!
i wurde autoboxed!

Also wird, wenn eine Methode mit einen primitive type und einem WrapperObject existiert, kein AutoBoxing/Unboxing vorgenommen. Gibt es aber keinen Methodenaufruf vom entsprechenden Typ wird das Autoboxing/Unboxing automatisch vorgenommen.

 

[bygones]

nachtrag:

dein zweites Bsp wird gar nicht kompiliert mit dem Hinweis, dass die methode foo ambigious sei !!!

 

[helium]

Ich verstehe zwar, das in einigen Situationen Anglizismen sinnvoll sein, aber währe "mehrdeutig" nicht mindestens genauso verständlich, wie "ambigious"?

 

[bygones]

sry - haben einfach aus dem compiler abgeschrieben

 

[Bleiglanz]

Der "Algorithmus" ist wie immer reichlich kompliziert:

http://jcp.org/aboutJava/communityprocess/jsr/tiger/autoboxing.html

IIf more than one method declaration is both accessible and applicable to a method invocation, it is necessary to choose one to provide the descriptor for the run-time method dispatch. The Java programming language uses the rule that the most specific method is chosen.
The informal intuition is that one method declaration is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time type error.
The precise definition is as follows. Let m be a name and suppose that there are two declarations of methods named m, each having n parameters. Suppose that one declaration appears within a class or interface T and that the types of the parameters are T1, . . . , Tn; suppose moreover that the other declaration appears within a class or interface U and that the types of the parameters are U1, . . . , Un. Then the method m declared in T is more specific than the method m declared in U if and only if both of the following are true:

· T can be converted to U by method invocation conversion.
· Tj can be converted to Uj by method invocation conversion, for all j from 1 to n.
A method is said to be maximally specific for a method invocation if it is applicable and accessible and there is no other applicable and accessible method that is more specific.
If there is exactly one maximally specific method, then it is in fact the most specific method; it is necessarily more specific than any other method that is applicable and accessible. It is then subjected to some further compile-time checks as described in §15.12.3 .
It is possible that no method is the most specific, because there are two or more maximally specific methods. In this case:

· If all the maximally specific methods have the same signature, then:

· If one of the maximally specific methods is not declared abstract, it is the most specific method.
· Otherwise, all the maximally specific methods are necessarily declared abstract. The most specific method is chosen arbitrarily among the maximally specific methods. However, the most specific method is considered to throw a checked exception if and only if that exception is declared in the throws clauses of each of the maximally specific methods.

· Otherwise, if exactly one of the maximally specific methods is applicable without use of boxing conversion, it is the most specific method.
Otherwise, we say that the method invocation is ambiguous, and a compile-time error occurs.