Questions d’entretien Java délicates

Il y a quelque temps, j’ai écrit un article sur les 50 meilleures questions de programmation Java. Nos lecteurs l’ont beaucoup apprécié. Aujourd’hui, nous examinerons donc quelques questions d’entretien délicates en Java.

Questions d’entretien délicates en Java

Il s’agit de questions de programmation, mais à moins d’avoir une compréhension approfondie de Java, il sera difficile de deviner la sortie et de l’expliquer.

1. Null comme argument

Nous avons des fonctions surchargées et nous passons null. Quelle fonction sera appelée et quelle sera la sortie du programme ?

public class Test {
	public static void main(String[] args) {
		foo(null);
	}
	public static void foo(Object o) {
		System.out.println("Object argument");
	}
	public static void foo(String s) {
		System.out.println("String argument");
	}
}

2. Utilisation de « L » pour long

Pouvez-vous deviner la sortie des déclarations ci-dessous ?

long longWithL = 1000*60*60*24*365L;
long longWithoutL = 1000*60*60*24*365;
System.out.println(longWithL);
System.out.println(longWithoutL);

Explication de la question délicate sur l’argument Null

Selon les spécifications de Java, en cas de surcharge, le compilateur choisit la fonction la plus spécifique. Évidemment, la classe String est plus spécifique que la classe Object, donc elle affichera « argument de type String ». Mais, que se passe-t-il si nous avons une autre méthode dans la classe comme ci-dessous.

public static void foo(StringBuffer i){
	System.out.println("StringBuffer impl");
}

Dans ce cas, le compilateur Java générera une erreur indiquant « La méthode foo(String) est ambiguë pour le type Test ». String et StringBuffer n’ont pas de hiérarchie d’héritage. Donc aucun des deux n’est plus spécifique que l’autre. Une méthode est plus spécifique qu’une autre si toute invocation gérée par la première méthode pourrait être transmise à l’autre sans erreur de type au moment de la compilation. Nous pouvons passer une chaîne de caractères en paramètre à un argument de type Object et à un argument de type String, mais pas à une méthode prenant un argument de type StringBuffer.

Explication pour la variable Long

La sortie du code sera:

31536000000
1471228928

Nous créons explicitement la première variable en tant que long en ajoutant un suffixe « L ». Ainsi, le compilateur le traitera comme un long et l’assignera à la première variable. Pour la deuxième instruction, le compilateur effectuera le calcul et le traitera comme un entier sur 32 bits. Puisque la sortie est en dehors de la plage de la valeur maximale d’un entier (2147483647), le compilateur tronquera les bits les plus significatifs puis l’assignera à la variable. L’équivalent binaire de 1000*60*60*24*365L = 011101010111101100010010110000000000 (36 bits). Après avoir supprimé les 4 bits les plus significatifs pour s’adapter à un entier sur 32 bits, la nouvelle valeur = 01010111101100010010110000000000 (32 bits). Ceci équivaut à 1471228928 et donc à la sortie. Récemment, j’ai créé une série de vidéos sur YouTube pour des programmes Java astucieux.

Vous pouvez consulter plus d’exemples de programmes Java dans notre Dépôt GitHub.