Bedeutung von Methodensignaturen und Aufrufverhalten

[kasi11]

Hallo,

für eine Klausur muss ich folgendes wissen:


"Die Bedeutung von Methodensignaturen und das sich daraus ergebende Aufrufverhalten. Beispiel:
public static int dazu(int a) { return a+1; }
public static double dazu(double z) { return z+2; }
Was wird aufgerufen bzw. ergibt dazu(1), dazu(1L), dazu(1F) und dazu(1.0) ?
Wem das nicht klar ist, der/dem kann ich nur empfehlen: Programm schreiben und ausprobieren."

Ich habe dann folgendes Programm geschrieben:

public class test {

public static int dazu(int a) { return a+1; };
public static double dazu(double z) { return z+2; } 

   public static void main (String [] nix)
   {

      System.out.println("1=="+dazu(1));
      System.out.println("1L=="+dazu(1L)); 
      System.out.println("1F=="+dazu(1F)); 
      System.out.println("1.0=="+dazu(1.0)); 

   } }

Nun ist meine Frage, was das denn nun für ein sich daraus ergebendes Aufrufverhalten ist. Und warum werden "1L" und "1F" überhaupt akzeptiert? Das ist ja weder int noch double.

Über eine Antwort wäre ich sehr dankbar

 

[kaoZ]

public static int dazu(int a) { return a+1; };

Statische Methode welche einen ihr übergebenen Wert um 1 addiert und zurückliefert.

public static double dazu(double z) { return z+2; }

Das gleiche in grün nur hier mit dem Datentyp double und es werden 2 hinzuaddiert.

System.out.println("1=="+dazu(1));
System.out.println("1L=="+dazu(1L));
System.out.println("1F=="+dazu(1F));
System.out.println("1.0=="+dazu(1.0));

Hier werden diese eingaben akzeptiert da ein double 64bit lang ist, (ein int nur 32bit) der Compiler weiß nun aber, das es sich um überladene Methoden handelt, also welche die identische Namen aber unterschiedliche Parameterlisten haben und das
du einen Datentyp übergibst der länger als 32bit ist , deshalb verwendet der Compiler also die Methode in die dein Datentyp, hier vom typ long und float jeweils passt,

demnach wird die Ausgabe auch durch Gleitpunkzahlen dargestellt.

Sprich es müsste dann zu folgender Ausgabe kommen :

1==2
1L==3.0
1F==3.0
1.0==3.0

Hier, vielleicht kannst du es hier dran besser nachvollziehen:

bit
byte = 8 bit
char = 16 bit
int = 32 bit
float = 32bit
long = 64bit
double = 64bit

einen Kleineren Datentyp kannst du immer einem größeren zuweisen, umgekehrt nur wenn du explizit einen Cast verwendest , dadurch weiß der Compiler das du weißt was du da tust

[EDIT]Dies erfolgt allerdings nicht Verlustfrei ![/EDIT]

 

[kasi11]

Ach alles klar, vielen Dank! Hätte mir die Datentypen nochmal genauer angucken sollen :rtfm: