Java: Quelle est la différence entre la sélection automatique et la diffusion?

Question

Cette question concerne & Pourquoi la sélection automatique fait-elle des appels ambigus en Java? "

Mais en lisant les réponses, il y a un certain nombre de références au casting et je ne suis pas sûr de bien comprendre la différence.

Quelqu'un peut-il fournir une explication simple?

Answer 1

La boxe, c’est lorsque vous convertissez un type primitif en un type référence, l’inverse est l’inverse. La transtypage se produit lorsque vous souhaitez qu'un type soit traité comme un autre type. Entre types primitifs et types de référence, cela signifie une opération de boxe implicite ou explicite. Que cela soit explicite ou non est une caractéristique du langage.

Answer 2

Le casting et la boxing / unboxing sont liés aux types et à la conversion apparente (ou réelle), mais boxing / unboxing est spécifique à la relation entre les types primitifs et leurs types de wrapper correspondants. de type au sens plus général.

Le casting est un terme général ayant deux significations liées mais non différentes:

1. Traitement d'une valeur d'un type comme si il s'agissait d'une valeur d'un autre type. Voici deux exemples de ces premiers usages:

   1.1. Etant donné que la classe B étend la classe A, vous pouvez demander à myB une instance de ((A) myB) d'être traitée comme une instance de Object en écrivant String partout où une référence à une instance de Map pourrait apparaître. Cela ne produit pas réellement une nouvelle instance de ((String) myMap.get(someKey)).length().

   1.2. Les collections antérieures à Java5 stockaient tout le contenu sous la forme length; Pour ce faire, vous devez généralement utiliser un casting après avoir récupéré un objet d'une collection. Par exemple, si vous aviez stocké un ((int) (float_var + 0.5F)) dans un (int) et deviez obtenir sa longueur, vous écririez quelque chose comme <=> où la conversion serait nécessaire pour appeler la méthode <=> de <= >. Encore une fois, cela ne provoque pas la création d’un nouveau <=>.

2. Convertissez explicitement un type en un autre (c'est-à-dire en modifiant explicitement la représentation). Un exemple de cette deuxième utilisation est dans l'expression <=> qui arrondit une variable à virgule flottante en ajoutant 0,5 (ce qui produit une valeur en virgule flottante), puis en convertissant explicitement cette valeur en un entier. La valeur entière résultante (après la <=> conversion) est produite à partir de l'autre valeur par calcul interne.

La conversion peut s'effectuer lorsqu'il existe une relation superclasse / sous-classe ou interface / implémenteur (signifiant 1 ci-dessus) ou lorsque les deux types sont des types numériques primitifs (signifiant 2). Vous pouvez rechercher & "Élargir &"; et " rétrécissement " pour plus de détails.

Boxing fait référence à l'encapsulation de types primitifs dans des objets conteneur, généralement uniquement lorsque vous devez disposer d'un objet (par exemple, stocker une valeur dans une collection). Les types primitif et wrapper viennent par paires:

int      Integer
long     Long
boolean  Boolean
...      ...

Unboxing signifie simplement récupérer la valeur primitive depuis son wrapper d'objet.

À partir de Java5, lorsque vous écrivez une expression qui utilise une valeur primitive où le type d'encapsuleur correspondant serait requis (par exemple, en plaçant un entier dans une collection), le compilateur insère automatiquement dans le code qui encapsule cette valeur primitive. De même, il vous fournira le code de décompression.

Donc, au lieu d'écrire (dans les versions antérieures à Java5) quelque chose comme:

Map myMap = new HashMap();
...
myMap.put(someKey,Integer.valueOf(3));
...
int nextValue = (myMap.get(someKey)).intValue() + 1;

vous pouvez écrire:

Map<KeyType,Integer> myMap = new HashMap<KeyType,Integer>();
...
myMap.put(someKey,3);
...
int nextValue = myMap.get(someKey) + 1;

et le code boxing / unboxing est inséré par le compilateur.

Answer 3

List<String> list = (List<String>)object;

est un casting.

void doSomething(Integer i) { ... }
...
doSomeething(5);

est la boxe automatique.

Integer getSomething();
...
int i = getSomething();

est unboxing automatique.

Answer 4

La variante automatique a été introduite dans Java 5 pour empêcher le code tel que:

map.put("ABC", new Integer(5));
map.put("DEF", new Integer(6));

Vous pouvez maintenant dire:

map.put("ABC", 5);

Bien que ce soit plus facile, il comporte quelques pièges si vous n'êtes pas tout à fait sûr de ce que vous faites.

Answer 5

La boxe encapsule une valeur dans un conteneur, telle qu'une valeur primitive int dans un objet Integer

Le casting est juste comment regarder le type.

Le premier produit un autre type de valeur, le dernier modifie simplement la façon de traiter une valeur existante

Excepté le transtypage entre types primitifs modifie réellement leur représentation. (Cela ne le rend pas plus clair ne le fait?)

Answer 6

La boxe et le déballage sont un type de conversion en Java, dans lequel vous effectuez une conversion d'une primitive vers sa classe wrapper ou l'inverse, par exemple. booléen en booléen (boîte) ou booléen en booléen (unbox).

Types de transtypes en Java, avec exemple:

• une conversion d'identité (& # 167; 5.1.1) Chaîne en chaîne

• une conversion de primitive d'élargissement (& # 167; 5.1.2) octet à int

• une conversion primitive restrictive (& # 167; 5.1.3) int à octet

• une conversion de référence élargie (& # 167; 5.1.5) Entier en nombre

• une conversion de référence plus étroite (& # 167; 5.1.6) Nombre à Entier

• une conversion de boxe (& # 167; 5.1.7) int en entier

• une conversion unboxing (& # 167; 5.1.8). Entier à int

La mise en correspondance automatique ou la mise en boîte automatique se produit lorsque le compilateur effectue la conversion boxing / unboxing pour vous (elle n'apparaît pas explicitement dans le code source en tant qu'expression de distribution), par exemple. voir la question à laquelle vous avez fait référence.

Answer 7

Les options Autoboxing et Unboxing peuvent-elles être appliquées dans le cas suivant?

Long one = 10;
long two = 15;
Long three = 20;

if(one == three) //will this be unboxed or do we need to put a explicit
                 //condition like if(one.intValue() == three.intValue()) 
   System.out.println("Equal");
else 
   System.out.println("Not Equal");  


if(one == two) //will this be unboxed or do we need to put a explicit
               //condition like if(one.intValue() == two) 
   System.out.println("Equal");
else 
   System.out.println("Not Equal");