# Überladene Methoden aussuchen



## paco89 (30. Nov 2011)

hallo, ich löse gerade folgende aufgabe:

a) "Betrachten Sie das folgende kurze Programm:


```
public class Ueberladen {

public static double foo ( double x , char y) { return 0; }                       // foo ( DC ) D

public static int foo ( double x , double y) { return 0; }                         // foo ( DD ) I

public static long foo ( char x , long y) { return 0; }                             // foo ( CJ ) J

public static byte foo ( char x , char y) { return 0; }                           // foo ( CC ) B

public static char foo ( float x , char y) { return 0; }                           // foo ( FC ) C

public static int foo ( int x , double y) { return 0; }                            // foo ( ID ) I

public static long foo ( double x) { return 0; }                                  // foo ( D ) J

public static long foo ( Float x) { return 0; }                                   // foo ( Float )J



public static void main ( String [] args ) {


byte x1 = ( byte ) 1;
long x2 = ( long ) 2;
double x3 = ( double ) 3;

double a1 = foo (.0 , .0 f ); // 1
int a2 = foo (x2 , 1L ); // 2
float a3 = foo (x1 , x2 ); // 3
long a4 = foo (1f , ’c ’); // 4
char a5 = foo (1L , ’y ’); // 5
double a6 = foo (x3 , ’z ’); // 6
long a7 = foo (1); // 7
}
}
```


Geben Sie für die sieben markierten Aufrufe von foo jeweils an, welche der verschiedenen Varianten der Funktion von Java verwendet wird. Verwenden Sie zur eindeutigen Bezeichnung die Funktionssignatur, die jeweils als
Kommentar hinter jeder Funktionsdeﬁnition steht. Begründen Sie Ihre Antwort kurz."


Meine Notizen sind folgende:

also überladene methoden dürfen ja den gleichen namen haben. rückgabewert und die parameterliste müssen unbedingt unterschiedlich sein. klar. soweit so gut. der compiler sucht sich ja dann die methode auf, die am besten passt. ich hoffe ich habe mich korrekt ausgedrückt, falls nicht, wisst ihr ja, was ich meine. und bei dieser aufgabe mussten wir so gesehen, die rolle des compilers übernehmen, bei welchen zuweisungen in der main-methode, welche statischen methoden am besten passen. sprich: ich muss die implizite typkonvertierung kennen, also dass immer vom "schmäleren" in einen "breiteren" Datentyp konvertiert wird. als antwort musste ich ja immer die signatur, welche als kommentar steht, angeben. Nun kommen wir zu meinen lösungen:

1. bei double a1: da habe ich mir überlegt, dass die Methode mit der Signatur foo(DD)I aufgerufen wird. denn als aktuelle parameter werden an den formalen parameter ein double- und ein float- wert übergeben. den float wert kann man problemlos in ein double konvertieren. also passt das. hoffe ich mal.


2. bei int a2= habe ich zwei werte vom typ long als aktuelle parameter. dazu habe ich mir die methode mit der signatur foo(DD)I ausgesucht. der grund ist genauso wie oben. long ist kleiner als double. also ist die implizite typkonvertierung kein problem.

3. float a3 = da habe ich einen byte und einen long-wert als aktuelle parameter. ich habe mich für die methode mit der signatur foo(ID)I entschieden, weil den byte wert kann ich problemlos in einen int casten, und das long in den größeren double.

4. long a4= hier habe ich einen float und einen cahr-wert. ich nehme die methode mit der signatur foo(FC)D. das passt einfach perfekt, denn die formalen parameter sind vom gleichen typ wie die aktuellen parameter.

5. char a5 = hier habe ich auch foo(FC)C, weil long kann ich ohne probleme in das nächst größere float umwandeln und char bleibt so.

6. double a6 = hier habe ich ein float und ein char. da eignet sich doch am besten die methode mit der signatur foo(DC)D. weil float kann ich locker in ein double umwandeln und char bleibt char.

7. long a7 = da habe ich einen einzigen byte wert als als aktuellen parameter. und ich habe einfach die methode mit der signatur foo(D)J genommen. 



ich hoffe, ich habs richtig...würde mich sonst über korrekturen freuen...



lg


----------



## Andi_CH (30. Nov 2011)

Antwort: Das Programm ist gar nicht lauffähig - es hat Fehler drin, also wird gar keine der Funktionen aufgerufen
-> Ich würde mich jetzt schon auf die Diskussion mit dem Dozenten, Professor oder was auch immer freuen, denn ich habe Recht - das Gegenteil müsste er mir erst beweisen.

.0 f -> vermutlich ist .0f gemeint
'c ' ist entweder ein String oder dann muss der Abstand weg


----------



## Marco13 (30. Nov 2011)

1. Darum geht es nicht
2. Darum geht es nicht

Sieht aus wie eine dieser SCJP-Fragen. Man sollte eine grobe Einschätzung haben, und wissen, dass ein "." einen gewaltigen Unterschied machen kann. Und dass man sich bei

```
List<Integer> list = someList;
Integer a = 1;
int b = 2;
list.remove(a);
list.remove(b);
```
genau überlegen sollte, welches 'remove' man eigentlich will, ist auch klar. Aber in diesem Fall ist die Verifikation ja einfach: Compilieren (nachdem man die unbedeutenden Tippfehler entfernt hat) und starten...


----------



## Andi_CH (30. Nov 2011)

Marco13 hat gesagt.:


> 1. Darum geht es nicht
> 2. Darum geht es nicht



Meinst du das weiss ich nicht? Aber glaub mir, ich hätte genau diese Antwort als Erste gegeben und dann "unter der Annahme, dass alles komplierbar ist" weitergerätselt - aber warum soll ich hier die Frage beantworten, deren Lösung man mit einem Debugger oder einigen sysouts prüfen kann?

Also
1. Annahmen aufschreiben
2. mit einem Debugger (oder geschickten sysout's) überprüfen
3. Wenn dann etwas anders kommt als angenommen, hier fragen warum - es gibt sicher welche die das genau begründen können.


----------



## Marco13 (30. Nov 2011)

Joa... erinnerte mich eben an ein Zitat unseres Mathe-Profs: "Mathematische Formeln sind immer so zu lesen, wie sie gemeint sind"


----------

