J'ai une question: je travaille dans l'environnement d'Eclipse.
Parfois, l'ordinateur ne donne pas le casting suivant:
int a ...
Object ans = (int) a;
Mais seulement cette conversion:
int a ...
Object ans = (Integer) a;
Je comprends pourquoi vous pouvez faire un casting de Object
à Integer
, mais pourquoi une variable primitive?
Je vous remercie
J'attache le code que le compilateur ne me permet pas de transtyper avec la variable int
à object:
/** @return minimum element */
public Object minimum(){
return minimum(this.root);
}
public Object minimum(BSTNode node){
if (node.left != null) return minimum(node.left);
return node.data;
}
/** @return maximum element */
public Object maximum(){
return maximum(this.root);
}
public Object maximum(BSTNode node){
if (node.right != null) return maximum(node.right);
return node.data;
}
public Object findNearestSmall(Object elem) {
int diff;
diff = (int)maximum() - (int)minimum();
if (compare(minimum(), elem) == 0) return elem;
else return findNearestSmall(elem, this.root, diff);
}
public Object findNearestSmall(Object elem, BSTNode node, int mindiff){
if(node == null) return (int)elem - mindiff;
int diff = (int)elem - (int)node.data;
if(diff > 0 && mindiff > diff) mindiff = diff;
/* Case 2 : Look for in left subtree */
if(compare(node.data, elem)>-1)
return findNearestSmall(elem, node.left, mindiff);
else
/* Case 3 : Look for in right subtree */
return findNearestSmall(elem, node.right, mindiff);
}
Avant Java 1.5, vous ne pouviez même pas faire ceci:
int a;
...
Object x = (Integer) a;
Le compilateur se plaint que a
est d'un type de données primitif et ne peut donc pas être converti en objet.
À partir de Java 1.5, Java a introduit le concept de automatique boxing . Donc, ce qui suit est devenu OK:
int a;
...
Object x = (Integer) a;
Parce que le compilateur sait comment convertir une primitive int
au type boxed Integer
automatiquement; et de Integer
à Object
, eh bien, ce n'est pas un problème.
Cependant, ce que vous essayez de faire:
int a;
...
Object x = (int) a;
Dit fondamentalement au compilateur de éviter la boxe. Vous indiquez explicitement au compilateur de laisser a
en tant que int
et de placer une référence à cette int
dans une Object
. Le compilateur n'est pas conçu pour traiter un tel cas.
Vous ne pouvez pas transtyper d'un type de données référencé vers un type de données primitif, c'est-à-dire que vous ne pouvez pas:
Object x = (int)a;
Vous pouvez cependant faire:
Object x = (Integer)a;
parce que Integer
est une classe et int
est un type de données primitif.
Si je le suppose correctement, la fonctionnalité que vous souhaitez obtenir consiste à obtenir la valeur de l’entier à partir de l’objet x, ce qui peut se faire de la manière suivante:
Object x = (Integer)a;
//Do something and somewhere else
int z = ((Integer)x).intValue();
Cela peut passer par une ClassCastException
si elle n'est pas de la classe Integer
.
Mais je suis capable d'exécuter le code suivant. J'utilise jdk 1.6 et le code suivant ne me renvoie aucune erreur ni exception d'exécution.
int i=5;
Object test = (int)i;
System.out.println(test.getClass());
Sortie: classe Java.lang.Integer
Une Integer
est également une Object
et reste en tant qu'objet sur le tas.
Une int
est un type primitif . Ce n'est pas une Object
. Un objet a ses propres propriétés d'état et comportementales, int
n'en a pas. Vous obtenez donc une erreur de compilation lorsque vous essayez de convertir un objet en primitive. D'autre part, la conversion d'un entier en objet est possible à cause de Autoboxing
Vous devriez examiner la différence entre int qui est un type primitif etInteger, qui est une classe wrapper en Java.