Blog rund um Java und den SCJP

die letzten Tage haben wir uns recht viele Beispiele angeschaut; was geht, was geht nicht, was geht unter welchen Umständen, etc.

Zum Abschluss dieses Themas (naja, fast, ich habe noch ein paar Übungen für einen späteren Zeitpunkt geplant) will ich die wichtigsten Infos nochmal zusammenfassen:

• Gib es bei Methodenaufrufen keine exakte übereinstimmung, wird der nächstgrößere Typ “gezogen”.
• Es wird immer nur der nächstgrößere, aber nie ein kleinerer Wert gezogen, auch wenn dieser theoretisch passen würde, da Datentypen zwar erweitert, aber nicht verkleinert werden können
• Für den Falle, dass sich der Compiler zwischen Autoboxing und dem größerem Wert entscheiden muss, wird immer der nächstgrößere Wert und nicht der Autoboxing-Wert gezogen.
• Bei Wahlmöglichkeit immer die genaue Anzahl von Werten gezogen wird und nicht eine variable Anzahl von Werten
• Diese Wahlmöglichkeitist unabhängig von Autoboxing
• Referenzvariablen können auch im Zuge des Polymorphismus erweitert werden, da ja jede Subklasse auch eine Überklasse ist.
• Wrapper können nicht andere Werte (außer ihrem eigenen primitven Wert) aufnehmen. Abhilfe schafft hier die Aufnahme per Object-Klasse und anschließenden expliziten Cast

Nochmal zur Erinnerung, dass man int-Werte mit Methoden, die einen long-wert aufnehmen aufrufen kann:

class Angestellter {

void getPosition(long a){

System.out.println(“Long-Übernahme”);

}

public static void main(String[] args) {

int b = 2;

Angestellter a = new Angestellter();

a.getPosition(b);

}

}

Dies funktioniert aber nicht bei Wrappern:

class Angestellter {

void getPosition(Long a){

System.out.println(“Long-Übernahme”);

}

public static void main(String[] args) {

int b = 2;

Angestellter a = new Angestellter();

a.getPosition(b);

}

}

Hier wird ein Compilerfehler (The method getPosition(Long) in the type Angestellter is not applicable for the arguments (Integer)) ausgegeben.

Referenzvariablen können auch im Zuge des Polymorphismus erweitert werden, da ja jede Subklasse auch eine Überklasse ist.

class Angestellter {

…

}

class Buchhalter extends Angestellter {

public static void main(String[] args) {

Buchhalter a = new Buchhalter();

a.getPosition(a);

}

void getPosition(Angestellter a) {

System.out.println(“Angestellter”);

}

}

Für unser Beispiel bedeutet dies, dass ja jeder Buchhalter auch ein Angestellter ist und deswegen diese Erweiterung funktioniert. Der Code wird fehler- und warnungsfrei compiliert

Vor ein paar Tagen haben wir gelernt, das bei einer Wahlmöglichkeit immer der genaue Wert gezogen wird. Dies ändert sich auch nicht, wenn Autoboxing ins Spiel kommt:
class Angestellter {

public void getPosition(int … a) {

System.out.println(“int …. a”);

}

public void getPosition(Integer a, Integer b) {

System.out.println(“Integer a, Integer b”);

}

public static void main(String[] args) {

int a = 1;

int b = 2;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a,b);

}

}

Ausgabe ist hier logischerweise Integer a, Integer b.

Ihr merkt schon, Überladung ist doch nicht ganz so einfach, wie gedacht.
Heute wollen wir uns mal ansehen, wie der Compiler reagiert, wenn 2 mögliche Aufnahmemethoden zur Verfügung stehen; einmal mit einer variablen Anzahl von Werten und einmal mit der genauen Anzahl der übergebenenen Werte:
class Angestellter {

public void getPosition(int … a) {

System.out.println(“int …. a”);

}

public void getPosition(int a, int b) {

System.out.println(“int a, int b”);

}

public static void main(String[] args) {

int a = 1;

int b = 2;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a,b);

}

}
Die Ausgabe ist int a, int b; da bei einer Wahlmöglichkeit immer der genaue Wert gezogen wird

Für den Falle, dass sich der Compiler zwischen Autoboxing und dem größerem Wert entscheiden muss, wird immer der nächstgrößere Wert und nicht der Autoboxing-Wert gezogen.
Hier mal wieder ein Beispiel:

class Angestellter {

public void getPosition(long a) {

System.out.println(“long-Methode”);

}

public void getPosition(Integer a) {

System.out.println(“Integer-Methode”);

}

public static void main(String[] args) {

int a = 1;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a);

}

}

Die Ausgabe ist wie erwartet “long-Methode”, da ja immer der nächstgrößere Wert gezogen wird.

Gib es bei Methodenaufrufen keine exakte übereinstimmung, wird der nächstgrößere Typ “gezogen”.

class Angestellter {

public void getPosition(int a) {

System.out.println(“int-Methode”);

}

public void getPosition(double a) {

System.out.println(“double-Methode”);

}

public static void main(String[] args) {

int a = 1;

long b = 2;

double c = 3;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a);

angestellter.getPosition(b);

angestellter.getPosition(c);

}

}

Ausgabe ist demnach:
int-Methode
double-Methode
double-Methode

Long zieht sich niemals int, da nur der nächstgrößere, aber kein kleinerer Wert (auch wenn diese theoretisch passen würden) gezogen wird. Es entsteht also eine Erweiterung des Datentyps.