Newsgroup: it.comp.java
Titolo: Conversioni di tipi

Ciao a tutti,
vi mancavo eh?
Ho un esercizio che mi chiede di scrivere un programma che legge un 
valore di tipo short e lo converte in un oggetto di tipo short e quindi 
converte quest'ultimo in un oggetto di tipo Integer. Poi mi chiede quali 
meccanismi di conversione sono necessari?
 
Io il programma l'ho scritto cosě:
 
import jbook.util.Input;
public class Esercizio43 {
	public static void main (String[] args) {
		short valore = Input.readShort("Inserisci un valore di tipo short: ");
		Short valoreObj = new Short (valore);
		Integer valoreObj2 = new Integer (valoreObj);
	}
}
 
Va bene secondo voi? Il compilatore non mi segnala errori.
Nella prima assegnazione ho creato una variabile di tipo short leggendo 
il valore passato dall'utente. Poi ho creato un oggetto short 
assegnandoli come contenuto il valore letto in precedenza e dandogli 
come riferimento il nome valoreObj. Di questo sono abbastanza sicura. 
L'ultimo passaggio non sono certa sia corretto.
Ho creato un altro oggetto di tipo integer assegnandogli come contenuto 
il valore dell'oggetto short e dandogli come riferimento il nome 
valoreObj2...
 
Alla domanda finale perň non so rispondere...
 
Grazie.

 Alla domanda finale però non so rispondere...
Beh, in effetti la domanda non e' precisissima. Immagino che si 
riferisca a quali conversioni e' assogettato l'input dell'utente per 
arrivare ad un Integer.
Una prima conversione deve avvenire nel metodo Input.readShort(), non ho 
la documentazione della classe jbook.util.Input, ma immagino che legga 
da standard input, ovvero l'oggetto statico System.in di tipo 
InputStream che ha solo metodi per leggere dei byte. Quindi una prima 
conversione penso che avvenga da un byte[], da cui si puo' ricavare una 
Stringa con new String(byte[]), dopodiche' si puo' convertire la stringa 
in short tramite il metodo Short.parseShort(String)
A questo punto il tuo short viene incapsulato in un Short senza 
conversioni. Poi c'e' la conversone a int mediante valoreObj.intValue() 
o, come facevi tu, mediante la promozione da Short a short e da short a int.
Di nuovo, incapsulando l'int in un Integer non c'e' conversione.
 

 valueOf e' un metodo statico che se puo' ritorna sempre la stessa istanza
 
 
Ti ringrazio ma prima di apprendere le raffinatezze mi sa che mi 
conviene imparare le basi :-))
 

Se non ho capito male mi stai dicendo che ho fatto bene 
 
veramente ti ha detto che non ha senso
perchè tu chiami il costruttore della classe Integer e gli passi un
Short
ma non esiste un costruttore nel wrapper Integer che accetti come
argomento specifico un Short
fa una conversione implicita lui... ma se avessi messo al posto di
Short  che ne so... Double,
non avrebbe funzionato probabilmente
 
 
ciao, Jasmine

 e poi promuovere l'istanza di classe short a istanza di classe int...
In realta', Poiche' la classe Integer ha due costruttori, uno che 
accetta un argomento di tipo String, e l'altro che accetta un tipo 
primitivo int, avresti dovuto utilizzare proprio il metodo intValue di 
Short per fare la conversione necessaria per beccare almeno uno dei due 
costruttori, cioe' convertire un oggetto di tipo Short in un valore 
primitivo di tipo int per poi ottenere un oggetto di tipo Integer.
Ma avresti potuto anche fare:
Integer valoreObj2 = new Integer (valoreObj.toString());
utilizzando l'altro costruttore con argomento String. In tal caso lo 
short incapsulato nell'oggetto valoreObj viene convertito nella sua 
rappresentazione alfanumerica mediante il metodo toString, e poi 
convertito in int dal costruttore Integer(String).
Cosi' come hai fatto tu, con una versione di Java precedente alla 5, il 
compilatore non te l'avrebbe passata.
 

 :-))
 
E hai ragione ma ti garantisco che agli occhi di chi sta avendo molte 
difficoltà ad elaborare certi concetti sembra tutto piu' difficile così...
 
Ora sono alle prese con un altro esercizio (evito di aprire un altro 
topic sennò mi sparate :-), questo è semplice ma non riesco lo stesso.
Devo scrivere un programma che legge un carattere e ne stampa il 
realtivo codice unicode corrispondente.
 
Ho fatto così:
 
		char carattere = Input.readChar("Inserisci un carattere: ");
		int car1 = (int) carattere;
		System.out.println("Il codice unicode per questo carattere e': " + car1);
 
e mi restituisce un numero per ogni carattere che scrivo, ma non mi pare 
che sia il codice unicode... il risultato non dovrebbe avere la forma 
\u0008 (es.)?
 
Ciao e grazie.

 \u0008 (es.)?
 
Forse si intende questo:
 
char carattere = Input.readChar("Inserisci un carattere: ");
System.out.println("Il codice unicode per questo carattere e': " + 
String.format("%c", carattere));
 
o magari cosi':
 
char carattere = Input.readChar("Inserisci un carattere: ");
int car1 = (int) carattere;
System.out.println("Il codice unicode per questo carattere e': " + 
String.format("\\u%04d", car1));

 String.format("\\u%04d", car1));
 
questo funziona, nel senso che ritorna il codice unicode nel formato \\uxxx
in effetti lo faceva anche prima solo che mi riportava solo il numero 
corrispondente senza la parte \u
però qualcosa non torna, sul libro c'e' una tabella di unicode in cui 
per esempio il carattere 'è' corrisponde a \u00E8 ma qui mi ritorna un 
altro valore...aiuto!
poi l'esercizio chiede di provare ad eseguire il codice per vedere cosa 
ritorna il programma per il whitespace e per la tabulazione \t però se 
provo a scrivere \t lui legge solo \...
 
francamente questo esercizio mi appare inspiegabile!
anche perché il metodo da te usato sopra String.format non è ancora 
spiegato da nessuna parte nel libro fin dove sono arrivata, perciò non 
si presume che uno usi quello...
 
ciao

 si presume che uno usi quello...
Ovviamente il metodo String.format lo si usa per comodità, ma quello che 
fa  String.format, che grosso modo corrisponde alla printf del C, lo si 
puo' fare diversamente. Purtroppo il tuo libro non ce l'ho, ti propongo 
un altro metodo, magari lo trovi piu' accettabile, anche se un po' 
macchinoso:
String hex = Integer.toHexString(car1).toUpperCase();
 
toHexString produce la rappresentazione esadecimale dell'intero come 
oggetto String, quindi potrà contenere i caratteri 0123456789abcdef, 
appicando il metodo toUpperCase gli eventuali caratteri abcdef verranno 
convertiti in maiuscolo. Pero' il metodo toHexString non conterra' alcun 
leading zero, quindi se vuoi una rappresentazione del tipo 00E8 vovrai 
aggiungere gli zeri necessari. Anche in questo caso ci sono vari metodi, 
forse il piu' semplice e' questo:
 
while (hex.length() < 4)
	hex = "0" + hex;
 
ora concateni la tua rappresentazione esadecimale alla stringa \u, in 
questo modo
 
hex = "\\u"+hex;
 
Alternativamente puoi utilizzare questo metodo;
String hex = "0000"+Integer.toHexString(car1).toUpperCase();
int beginIndex= hex.length()%4;
hex = "\\u"+hex.substring(beginIndex==0?hex.length()==8?4:0:beginIndex-1);
 
il metodo substring(int beginIndex) di String restituisce la porzione 
dell'oggetto String a partire dall'indice beginIndex, l'operatore % 
restituisce il resto della divisione tra interi, quindi se 
toHexString(car1) conteneva 3 caratteri, il metodo length() di String 
applicato alla variabile hex restituisce 7, 7%4 da 3 poiche' l'indice 
parte da 0, occorre sottrarre 1, per cui la sottostringa finale 
conterra' un solo zero dei 4 aggiunti inizialmente.
Nota la correzione:
beginIndex==0?hex.length()==8?4:0:beginIndex-1
beginIndex vale 0 sia che la lunghezza di hex sia 0, 4 o 8 (e anche 
tutti gli altri multipli di 4, caso che no si presentera' nella 
fattispecie), per cui se la lunghezza di hex era 8 l'indice dovra' 
essere 4, per ottenere la sottostringa a partire dal quinto carattere.
 

Rinuncio a quell'esercizio, incomprensibile. Devo passare oltre 
altrimenti non finisco mai...l'esame si avvicina!! Argh!
Sono alle prese con gli array.
Ecco un concetto che non riesco ad afferrare:
 
"Dopo aver creato un array si può:
1) definire le prime dimensioni dell'array (una sequenza non vuota di 
espressioni intere ciascuna racchiusa tra parentesi quadre) lasciando 
indefinite le ultime dimensioni (una sequenza anche vuota di parentesi 
quadre aperte e chiuse)
oppure
2) definire il numero complessivo di dimensioni dell'array (una sequenza 
non vuota di parentesi quadre aperte e chiuse) e usare un'espressione di 
inizializzazione per definirne gli elementi.
Nel primo caso gli elementi corrispondenti alle dimensioni non 
specificate sono riferimenti vuoti (null)."
 
 
Ma che cosa si intende per "prime e ultime dimensioni dell'array" e 
numero complessivo di dimensioni dell'array??
Si intende per caso per prime dimensioni quelle che l'array ha appena è 
stato creato e per ultime quelle che l'array avrà dopo l'esecuzione del 
programma (e quindi l'eventuale immissione di dati)?
Davvero questo libro per me è arabo. Forse sono io che sono tonta, non so.
 
 
 

il 10.02.2012 11:30, Scrive Jamie 105806016:

No, vuole dire che un array a molte dimensioni puo' essere definito 
specificando le dimensioni solo parzialmente.  Visto che se ci sono 
delle dimensioni indefinite, le dimensioni successive non possono essere 
definite, il tuo testo utilizza questa dizione un po' sfortunata, 
volendo significare con "prime" tutte le dimensioni definite, e con 
"ultime" le rimanenti dimensioni indefinite.
Una dimensione e' definita quando ne viene specificato il numero massimo 
di elementi.
 
Object[] oa1;
e' un array a 1 dimensione, mentre
Object[][] oa2;
ne ha due, ovviamente le dimensioni possono essere di piu', in pratica 
un array a piu' dimensioni e' una matrice
 
il caso 1) equivale a scrivere:
 
Object[1][] oa2;
in questo caso la prima dimensione e' definita e l'ultima non lo e'
 
il caso 2) equivale a scrivere:
 
Object[1][2] oa2 = {{"1", "2"}};
 
 

 "ultime" le rimanenti dimensioni indefinite.
 
Quindi creando una matrice è  necessario definire sicuramente il numero 
di "colonne"(array, identificati con [] ) ma non il numero delle righe 
dei vari array (cioè il numero che sta dentro le [] ) che lo 
compongono...giusto?
Ma questo non contrasta col fatto che "la creazione dell'oggetto array 
comprende l'allocazione della memoria necessaria a rappresentarne tutti 
gli elementi e quindi richiede che sia noto il numero di elementi 
dell'array, cioè la lunghezza" ? (sempre tratto dal famigerato libro, 
che poi questo "limite" si aggira con arraylist ma ancora non ne parla lì)
Come mai se parliamo di matrici a java non gliene frega niente se ne 
creo una con una colonna di lunghezza stabilita e un'altra no?
Un'altra cosa: nell'assurdo che si debba creare un array di, boh, 1000 
array, cosa dovrebbe fare un povero programmatore, scrivere 1000 volte 
le []???
 
[to be continued]

 [to be continued]
 

On 10/02/2012 15:41, Dr.Ugo Gagliardelli wrote:
 
 
Ma quando si dice "variabili del medesimo tipo classe" si intende 
variabili riferimento ad oggetti istanziati?
E in questo caso l'istruzione a1=a2, ponendo che appunto a1 e a2 siano 
quanto sopra, copia il riferimento a1 nel riferimento a2?
Oppure copia anche i valori delle variabili di istanza di a2 in a1? No 
questa penso di no...essendo variabili di istanza l'assegnamento copia 
solo il riferimento. Credo.
 
(scusa se salto da una argomento all'altro ma mi vengono atroci dubbi 
ogni istante andando avanti con le letture)

 solo il riferimento. Credo.
Esatto, i membri dei due oggetti (le variabili di istanza) saranno 
uguali a corollario del fatto che le variabili a1 e a2 rappresentano la 
stessa istanza.
