Perché non è possibile eseguire il cast di un oggetto/valore byte per oggetto doppio? la conversione da Byte a Double influenza la precisione?

Question

public class Primitive { 
    public static void main(String []args) { 


    byte x=5; 
    Double y=(Double)x; //Error : Cannot cast from byte to Double. 

    Byte n=7; 
    Double m=(Double)n; //Error : cannot cast from Byte to Double. 

    double c=n; //working right ..."double is primitive and Byte is object ". 
    } 
} 

A che scopo impedire la trasmissione di Byte a Double? .. so Double to Byte per ragioni di precisione se non sbaglio.

Answer 1

Si stava tentando di trasmettere una primitiva byte alla classe Double, che non è possibile eseguire. Se si tenta il seguente codice, invece, non sarà un problema:

byte x=5; 
double y = (double)x; // No error 

Se si desidera utilizzare la classe al posto del primitivo doubleDouble, allora si può provare questo:

byte x=5; 
Double y = Double.valueOf(x).doubleValue(); 

Answer 2

Il la risposta è il modo in cui i tipi primitivi sono auto-boxed per i tipi di wrapper in Java. Puoi anche fare qualcosa come

Double y = Byte.valueOf(x).doubleValue(); 
Double z = (double) x; 

Answer 3

Il doppio con lettere maiuscole è una classe, non un primitivo.

Che cosa si vuole fare è

byte x=5; 
double y=(double)x; 

byte n=7; 
double m=(double)n; 

double c=n; 

Casting una doppia in un byte con la perdita causa di precisione (perderai tutti i decimali). Un byte è come un int ma lungo 8 bit.

Answer 4

Perché è così che auto-boxing e un-boxing funziona.

Questo codice funziona benissimo:

byte x = 5; 
    Integer i = (int) x; 

Motivo: boxe mappa di conversione primitive e le loro involucridirettamente. Quello che sto dicendo è solo un byte può essere convertito in un byte senza il tipo di casting esplicito. Se avete bisogno di convertire un byte ad un Double, è necessario utilizzare in modo esplicito o meno così:

byte x = 5; 
    Double d = (Double) (double) x; 

perché solo una double può essere convertito in un Double.

Answer 5

Si può dare un'occhiata a questo documentation di autoboxing e unboxing.

Autoboxing e unboxing consente agli sviluppatori di scrivere codice più pulito, semplificando la lettura. Nella tabella seguente sono elencati i tipi primitivi e le loro corrispondenti classi wrapper, che vengono utilizzati dal compilatore Java per autoboxing e unboxing:

Quindi, in base a questa tabella non si può direttamente autobox così come può non castato a doppio da byte. Inoltre, non puoi annullare l'operazione di unbox per raddoppiare da Byte.

---

Ma si può lanciare primitivo al tipo primitivo e poi autobox al suo oggetto di classe Wrapper. E puoi unboxare l'oggetto di classe Wrapper al suo tipo primitivo e quindi lanciarlo ad altri tipi primitivi.

byte x = 5; 
double temp = x; 
Double y = temp; 

// Can be written as 
byte x1 = 5; 
Double y1 = (double) x1; 

// ================ 
Byte n = 7; 
byte byteVal = n; 
double doubleVal = byteVal; 
Double m = doubleVal; 

// Can be written as 
Byte n1 = 7; 
Double m1 = (double) (byte) n1; 

// ================= 
// But I still wonder how below code is working 
double c = n;