[JAVA] un dubbio o mistero da sfatare

misterx · 07-11-2003, 13:56

questa banalissima classe se compilata da luogo a questo fatto per me misterioso ed alquanto curioso.

Se si assegna y=x il file generato è di 410 bytes mentre se si assegna x=x il file generato è di 409 bytes

perchè ?

Codice:

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

    int x = 0;
    double y = 0;
    
    y = x;

  }
}

attenzione!!!!

non è FORTRAN

cn73 · 07-11-2003, 14:36

Cosa c'è di strano?? x e y sono di 2 tipi differenti, e diverso sarà il modo del compilatore di tradurlo in bytecode no??

cn73 · 07-11-2003, 14:46

Per farti capire quante differenze ci possono essere, guarda come viene disassemblato il codice della tua banale classe con y=x:

Codice:

Disassembling: C:\Marco\varie\x\Test.class
 
--------        ------------------------------        -----
 OFFSET                   FIELD NAME                  VALUE
--------        ------------------------------        -----
 
00000000        Signature                             CAFE BABE
00000004        Minor Version                         3
00000006        Major Version                         45
 
Constant Pool
 
00000008        Constant Pool Count                   17
0000000a        CONSTANT_Class                        Entry (1) (14)
0000000d        CONSTANT_Class                        Entry (2) (16)
00000010        CONSTANT_Methodref                    Entry (3) Class (2) Name/Type (4)
00000015        CONSTANT_NameAndType                  Entry (4) Name (7) Type (5)
0000001a        CONSTANT_Utf8                         Entry (5) ()V
00000020        CONSTANT_Utf8                         Entry (6) ([Ljava/lang/String;)V
00000039        CONSTANT_Utf8                         Entry (7) <init>
00000042        CONSTANT_Utf8                         Entry (8) Code
00000049        CONSTANT_Utf8                         Entry (9) ConstantValue
00000059        CONSTANT_Utf8                         Entry (10) Exceptions
00000066        CONSTANT_Utf8                         Entry (11) LineNumberTable
00000078        CONSTANT_Utf8                         Entry (12) LocalVariables
00000089        CONSTANT_Utf8                         Entry (13) SourceFile
00000096        CONSTANT_Utf8                         Entry (14) Test
0000009d        CONSTANT_Utf8                         Entry (15) Test.java
000000a9        CONSTANT_Utf8                         Entry (16) java/lang/Object
000000bc        CONSTANT_Utf8                         Entry (17) main
 
000000c3        Access Flags                          ACC_SUPER 
000000c5        This Class                            Test
000000c7        Super Class                           java/lang/Object
 
Interfaces
 
000000c9        Interfaces Count                      0
 
Fields
 
000000cb        Fields Count                          0
 
Methods
 
000000cd        Methods Count                         2
 
Method #1
 
000000cf        Access Flags                          ACC_PUBLIC ACC_STATIC 
000000d1        Name                                  main
000000d3        Type                                  ([Ljava/lang/String;)V
000000d5        Attributes Count                      1
000000d7        Attribute Name                        Code
000000d9        Bytes Count                           44
000000dd        Max Stack                             2
000000df        Max Locals                            4
000000e1        Code Count                            8
 
       0        iconst_0
       1        istore_1
       2        dconst_0
       3        dstore_2
       4        iload_1
       5        i2d
       6        dstore_2
       7        return
 
000000ed        Handlers Count                        0
000000ef        Attributes Count                      1
000000f1        Attribute Name                        LineNumberTable
000000f3        Bytes Count                           18
000000f7        Lines Count                           4
000000f9        Start PC                              0
000000fb        Line Number                           5
000000fd        Start PC                              2
000000ff        Line Number                           6
00000101        Start PC                              4
00000103        Line Number                           8
00000105        Start PC                              7
00000107        Line Number                           3
 
Method #2
 
00000109        Access Flags                          
0000010b        Name                                  <init>
0000010d        Type                                  ()V
0000010f        Attributes Count                      1
00000111        Attribute Name                        Code
00000113        Bytes Count                           29
00000117        Max Stack                             1
00000119        Max Locals                            1
0000011b        Code Count                            5
 
       0        aload_0
       1        invokespecial java/lang/Object/<init>()V
       4        return
 
00000124        Handlers Count                        0
00000126        Attributes Count                      1
00000128        Attribute Name                        LineNumberTable
0000012a        Bytes Count                           6
0000012e        Lines Count                           1
00000130        Start PC                              0
00000132        Line Number                           1
 
Attributes
 
00000134        Attributes Count                      1
 
Attribute #1
 
00000136        Attribute Name                        SourceFile
00000138        Bytes Count                           0
0000013c        Source File                           Test.java

misterx · 07-11-2003, 14:58

infatti, questo mi aspettavo da te

non ho colto la differenza tra le due versioni

puoi separarle ?

cn73 · 07-11-2003, 15:01

ok ti posto anche l'altra...dammi un secondo

cn73 · 07-11-2003, 15:02

La versione con x=x;

Codice:

Disassembling: C:\Marco\varie\x\Test.class
 
--------        ------------------------------        -----
 OFFSET                   FIELD NAME                  VALUE
--------        ------------------------------        -----
 
00000000        Signature                             CAFE BABE
00000004        Minor Version                         3
00000006        Major Version                         45
 
Constant Pool
 
00000008        Constant Pool Count                   17
0000000a        CONSTANT_Class                        Entry (1) (14)
0000000d        CONSTANT_Class                        Entry (2) (16)
00000010        CONSTANT_Methodref                    Entry (3) Class (2) Name/Type (4)
00000015        CONSTANT_NameAndType                  Entry (4) Name (7) Type (5)
0000001a        CONSTANT_Utf8                         Entry (5) ()V
00000020        CONSTANT_Utf8                         Entry (6) ([Ljava/lang/String;)V
00000039        CONSTANT_Utf8                         Entry (7) <init>
00000042        CONSTANT_Utf8                         Entry (8) Code
00000049        CONSTANT_Utf8                         Entry (9) ConstantValue
00000059        CONSTANT_Utf8                         Entry (10) Exceptions
00000066        CONSTANT_Utf8                         Entry (11) LineNumberTable
00000078        CONSTANT_Utf8                         Entry (12) LocalVariables
00000089        CONSTANT_Utf8                         Entry (13) SourceFile
00000096        CONSTANT_Utf8                         Entry (14) Test
0000009d        CONSTANT_Utf8                         Entry (15) Test.java
000000a9        CONSTANT_Utf8                         Entry (16) java/lang/Object
000000bc        CONSTANT_Utf8                         Entry (17) main
 
000000c3        Access Flags                          ACC_SUPER 
000000c5        This Class                            Test
000000c7        Super Class                           java/lang/Object
 
Interfaces
 
000000c9        Interfaces Count                      0
 
Fields
 
000000cb        Fields Count                          0
 
Methods
 
000000cd        Methods Count                         2
 
Method #1
 
000000cf        Access Flags                          ACC_PUBLIC ACC_STATIC 
000000d1        Name                                  main
000000d3        Type                                  ([Ljava/lang/String;)V
000000d5        Attributes Count                      1
000000d7        Attribute Name                        Code
000000d9        Bytes Count                           37
000000dd        Max Stack                             1
000000df        Max Locals                            2
000000e1        Code Count                            5
 
       0        iconst_0
       1        istore_1
       2        iload_1
       3        istore_1
       4        return
 
000000ea        Handlers Count                        0
000000ec        Attributes Count                      1
000000ee        Attribute Name                        LineNumberTable
000000f0        Bytes Count                           14
000000f4        Lines Count                           3
000000f6        Start PC                              0
000000f8        Line Number                           5
000000fa        Start PC                              2
000000fc        Line Number                           8
000000fe        Start PC                              4
00000100        Line Number                           3
 
Method #2
 
00000102        Access Flags                          
00000104        Name                                  <init>
00000106        Type                                  ()V
00000108        Attributes Count                      1
0000010a        Attribute Name                        Code
0000010c        Bytes Count                           29
00000110        Max Stack                             1
00000112        Max Locals                            1
00000114        Code Count                            5
 
       0        aload_0
       1        invokespecial java/lang/Object/<init>()V
       4        return
 
0000011d        Handlers Count                        0
0000011f        Attributes Count                      1
00000121        Attribute Name                        LineNumberTable
00000123        Bytes Count                           6
00000127        Lines Count                           1
00000129        Start PC                              0
0000012b        Line Number                           1
 
Attributes
 
0000012d        Attributes Count                      1
 
Attribute #1
 
0000012f        Attribute Name                        SourceFile
00000131        Bytes Count                           0
00000135        Source File                           Test.java

misterx · 07-11-2003, 15:02

Quote:

Originariamente inviato da cn73
ok ti posto anche l'altra...dammi un secondo

vai che stasera tiro le orecchie al prof

mi aveva detto che a livello di bytecode non cambiava nulla

misterx · 07-11-2003, 15:03

scusa cn

puoi metterli su due file txt separati ?

grazie 1000

cn73 · 07-11-2003, 15:04

Occhio però che questo non è bytecode... e Assembler... il bytecode lo puoi vedere aprendo il.class con un editor di testo...Cmq le differenze ci sono eccome...basta che li apri entrambi...cambiano parecchi valori esadecimali...

cn73 · 07-11-2003, 15:06

Quote:

Originariamente inviato da misterx
scusa cn

puoi metterli su due file txt separati ?

grazie 1000

Sono in 2 post separati...fai un copia e incolla...

misterx · 07-11-2003, 15:25

grazie 1000

PGI · 07-11-2003, 16:21

Quote:

Originariamente inviato da misterx
vai che stasera tiro le orecchie al prof

mi aveva detto che a livello di bytecode non cambiava nulla

Se devi andare dal professore per rinfacciargli qualcosa ti consiglio di andarci preparato

http://java.sun.com/docs/books/vmspe...ecTOC.doc.html

Tra le molte cose che si scoprono in quelle pagine web, c'è anche la struttura e gli operatori del bytecode java.
...
x=x
è più corto di
y=x

perchè y è un double e x un int, ragion per cui il bytecode generato conterrà l'istruzione "i2d" (integer to double), appartenente alla "serie" degli operatori JVM di conversione dei tipi "T2T".

Dai un occhiata a alle specifiche della jvm, si scoprono veramente cose curiose

&Ciao

PGI · 07-11-2003, 16:28

Quote:

Originariamente inviato da cn73
La versione con x=x;

Codice:

 
       0        iconst_0
       1        istore_1
       2        iload_1
       3        istore_1
       4        return

Non vorrei dire una stupidaggine, ma questo dovrebbe essere generato da un codice in cui manca la dichiarazione e l'assegnamento di y, cioè non

int x=0;
double y=0;
x=x;

ma

int x=0;
x=x;

Perchè manca un dconst (caricamento nello stack di un valore double costante) e un dstore (estrazione dallo stack e assegnamento a variabile di un valore double). Okkio se porti questo al prof, dovrebbe accorgersene

misterx · 07-11-2003, 23:28

Quote:

Originariamente inviato da PGI
Se devi andare dal professore per rinfacciargli qualcosa ti consiglio di andarci preparato

http://java.sun.com/docs/books/vmspe...ecTOC.doc.html

Tra le molte cose che si scoprono in quelle pagine web, c'è anche la struttura e gli operatori del bytecode java.
...
x=x
è più corto di
y=x

perchè y è un double e x un int, ragion per cui il bytecode generato conterrà l'istruzione "i2d" (integer to double), appartenente alla "serie" degli operatori JVM di conversione dei tipi "T2T".

Dai un occhiata a alle specifiche della jvm, si scoprono veramente cose curiose

&Ciao

la mia era una battuta, ci mancherebbe che vado a sfidare un prof; amo la vita tranquilla

il discorso è nato in aula quando si parlava della promozione di un int che viene convertito o "promosso" in double durante la compilazione

invece sembrerebbe che non viene convertito permanentemente un int in un doble, ma viene inserito nel bytecode codice atto a promuovere un int in un double solo se ve ne fosse la necessità

ho capito giusto ?

PGI · 08-11-2003, 11:59

Quote:

Originariamente inviato da misterx
invece sembrerebbe che non viene convertito permanentemente un int in un doble, ma viene inserito nel bytecode codice atto a promuovere un int in un double solo se ve ne fosse la necessità

ho capito giusto ?

Direi di sì, però ho qualche dubbio circa la conversione del valore di una variabile. Devo rileggermi un po' di cose prima di dare una risposta "certa", ma a naso direi che la conversione permanente non esista, cioè una variabile int non diventerà mai un double, al massimo il suo valore può essere temporaneamente promosso a double durante un'assegnazione o un'operazione...ma devo controllare.

misterx · 10-11-2003, 14:18

Parlando di linguaggio java, cosa significano le due definizioni (a) (b) ?

Sempre se le due definizioni sono corrette.

(a) metodo statico
String iString = String.valueOf(i);

(b) metodo classico
int iLung = iString.lenght();

PGI · 10-11-2003, 15:35

Quote:

Originariamente inviato da misterx
Parlando di linguaggio java, cosa significano le due definizioni (a) (b) ?

Sempre se le due definizioni sono corrette.

(a) metodo statico
String iString = String.valueOf(i);

(b) metodo classico
int iLung = iString.lenght();

a) statico o "di classe" è l'aggettivo usato per definire metodi o campi di cui esiste una sola istanza per classe. Se inizializzi 300 oggetti String, ogni volta che chiami "miaStringa123.valueOf(i)" quel "valueOf" ti riferisci ad un metodo che risiede in una locazione di memoria identica per ogni oggetto String. In pratica ll metodo è allocato in memoria 1 sola volta durante l'inizializzazione della classe String e ogni istanza di String "risponde" alla chiamata "valueOf" con il contenuto di quella parte di memoria.
Tutti i metodi/campi "static" di una classe vengono "realizzati" durante l'inizializzazione della classe. L'uso di un metodo o l'accesso ad un campo "static" che preceda l'inizializzazione della classe a cui appartengono produce automaticamente l'inizializzazione della classe: supponendo di avere una classe così composta:

Codice:

public class MiaClasse {
 public static int valore=0;
}

se in un'altra applicazione scriviamo

Codice:

int numero=MiaClasse.valore;

l'accesso a "valore" produce l'inizializzazione preventiva di "MiaClasse". Nota che l'inizializzazione di classe è un processo eseguito 1 sola volta per ogni classe, a prescindere dal numero di istanze della classe e, nel caso dell'invocazione di un metodo static, anche senza creazione di un'istanza di classe.

b) "classico" è la prima volta che lo sento, ma per definire i metodi che non sono static di solito "tutto fa brodo".
A differenza dei metodi/campi "static" i metodi "classici" (o non-static) hanno una locazione di memoria assegnata che è diversa per ogni istanza della classe, il che equivale a dire che, nel nostro caso, esiste un "lenght()" per ogni oggetto String che crei. A differenza dei metodi/campi static l'allocazione di memoria è fatta in corrispondenza della prima chiamata al metodo. Supponiamo di avere una classe così:

Codice:

public class MiaClasse {
 public static void metodoStatico();
 public void metodoClassico();
}

Se eseguissimo un codice così:

Codice:

MiaClasse classe=new MiaClasse();

viene allocato e inizializzato lo spazio di memoria per "metodoStatico()", vale a dire che "metodoStatico()" esiste già mentre "metodoClassico()" non ha ancora un contenuto. Scrivendo:

Codice:

classe.metodoClassico();

viene inizializzato anche "metodoClassico()" (l'inizializzazione dei metodi non-static è anch'essa eseguita 1 sola volta ma per ogni istanza della classe e non una volta per tutte).

In pratica la differenza tra i metodi static e quelli non static stà nel momento dell'inizializzazione e nell'unità del riferimento: il fatto che l'invocazione di uno "static" inizializzi le classi non ancora "realizzate" spiega anche come faccia la JVM a sapere quale sia il valore a cui deve accedere anche senza un'istanza della classe.

La sintesi non è il forte, vero?

&Ciao.

misterx · 13-11-2003, 18:53

ho letto la tua risposta con super interesse ed ancora qualche dubbio mi è rimasto; prima però di chiedere lumi a proposito di static o non static faccio un'altra domanda

supponiamo che mi venga in mente di scrivermi una bella classe, ad esempio una classe che serve a contare le ricorrenze della lettera a in un testo

e supponiamo che mi interessa utilizzare un metodo presente già in un'altra classe

domanda:
quando scrivo la mia classe devo includere del codice che richiami l'altra classe per poter usare i suoi metodi ?

mah, mi sa che non sono ancora pronto per domande del genere

scusa per la poca chiarezza ma mi serve anche da verifica e cioè, se non so domandare significa che non ho ancora capito

PGI · 13-11-2003, 19:36

Quote:

Originariamente inviato da misterx
quando scrivo la mia classe devo includere del codice che richiami l'altra classe per poter usare i suoi metodi ?

Tralasciando il modificatore "static" la risposta è sì. Va detto però che il concetto di "inclusione del codice", che è (forse) proprio della programmazione modulare, mal si addice alla programmazione orientata agli oggetti (sopratutto con un linguaggio OO puro come Java). Cosa che si capisce abbastanza bene traducendo in Java quel "includere codice per usare i metodi di un'altra classe" che si riduce alla creazione di una nuovo oggetto a partire dal modello definito nella classe.

Codice:

Object oggetto=new Object(); <-- tutto qua :)

oggetto.nomeMetodo(...) e via così...

Ci sarebbe a dire il vero anche un problema di visibilità della classe dei metodi e dei campi a cui vuoi accedere e che dipende dal rapporto tra gli oggetti che crei/usi e dai modificatori di visibilità che usi (public, private, protected e modificatore-default, applicato se non specifichi).

public applicato ad una classe consente la creazione di istanze da un package esterno a quello di appartenenza della classe (se non specifichi il modificatore risulta invisibile all'esterno del package). L'alternativa è l'uso del modificatore di default (scelto se non si specifica "public") che nega l'accesso all'esterno del package.

per campi e metodi, public consente l'accesso ovunque e comunque (classe/sottoclasse dello stesso package, classe/sottoclasse esterna al package);

private consente l'accesso alla sola classe in cui il metodo è stato definito;

protected nega l'accesso ad una classe esterna al package che non sia estensione della classe che definisce il metodo;

"default=nessun modificatore" limita l'accesso all'ambito del package (classi e sottoclassi esterne non "vedono" il metodo/campo).

Per le classi interne valgono le regole dei campi/metodi.

misterx · 13-11-2003, 20:13

scusa ma non so se sono riuscito a farmi capire

supponiamo che io scriva la classe Negozianti() e che al suo interno abbia implementato il metodo PagoBancomat()

ora scrivo la classe Pizzeria() con all'interno i suoi bei metodi

un'altra classe di nome Cartoleria()

ora mi metto a scrivere un programma che fa uso di tali classi ma così come sono, posso ad esempio usare il metodo PagoBancomat() presente nella classe Negozianti() senza che io nel momento della fabbricazione delle classi Pizzeria() e Cartoleria() abbia messo il benchè minimo legame tra loro ?

esempio:
Pizzeria cliente = new Pizzeria();

cliente.PagoBancomat(); - posso fare così ?

07-11-2003, 13:56	#1
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	[JAVA] un dubbio o mistero da sfatare questa banalissima classe se compilata da luogo a questo fatto per me misterioso ed alquanto curioso. Se si assegna y=x il file generato è di 410 bytes mentre se si assegna x=x il file generato è di 409 bytes perchè ? Codice: class Test { public static void main (String[] args){ int x = 0; double y = 0; y = x; } } attenzione!!!! non è FORTRAN Ultima modifica di misterx : 09-12-2003 alle 22:24.

07-11-2003, 14:36	#2
cn73 Senior Member Iscritto dal: Jul 1999 Città: Torino Messaggi: 2221	Cosa c'è di strano?? x e y sono di 2 tipi differenti, e diverso sarà il modo del compilatore di tradurlo in bytecode no?? Ultima modifica di cn73 : 07-11-2003 alle 14:39.

07-11-2003, 14:58	#4
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	infatti, questo mi aspettavo da te non ho colto la differenza tra le due versioni puoi separarle ?

07-11-2003, 15:01	#5
cn73 Senior Member Iscritto dal: Jul 1999 Città: Torino Messaggi: 2221	ok ti posto anche l'altra...dammi un secondo

07-11-2003, 15:03	#8
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	scusa cn puoi metterli su due file txt separati ? grazie 1000

07-11-2003, 15:04	#9
cn73 Senior Member Iscritto dal: Jul 1999 Città: Torino Messaggi: 2221	Occhio però che questo non è bytecode... e Assembler... il bytecode lo puoi vedere aprendo il.class con un editor di testo...Cmq le differenze ci sono eccome...basta che li apri entrambi...cambiano parecchi valori esadecimali...

07-11-2003, 15:25	#11
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	grazie 1000

10-11-2003, 14:18	#16
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	Parlando di linguaggio java, cosa significano le due definizioni (a) (b) ? Sempre se le due definizioni sono corrette. (a) metodo statico String iString = String.valueOf(i); (b) metodo classico int iLung = iString.lenght();

13-11-2003, 18:53	#18
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	ho letto la tua risposta con super interesse ed ancora qualche dubbio mi è rimasto; prima però di chiedere lumi a proposito di static o non static faccio un'altra domanda supponiamo che mi venga in mente di scrivermi una bella classe, ad esempio una classe che serve a contare le ricorrenze della lettera a in un testo e supponiamo che mi interessa utilizzare un metodo presente già in un'altra classe domanda: quando scrivo la mia classe devo includere del codice che richiami l'altra classe per poter usare i suoi metodi ? mah, mi sa che non sono ancora pronto per domande del genere scusa per la poca chiarezza ma mi serve anche da verifica e cioè, se non so domandare significa che non ho ancora capito

13-11-2003, 20:13	#20
misterx Senior Member Iscritto dal: Apr 2001 Città: Milano Messaggi: 3612	scusa ma non so se sono riuscito a farmi capire supponiamo che io scriva la classe Negozianti() e che al suo interno abbia implementato il metodo PagoBancomat() ora scrivo la classe Pizzeria() con all'interno i suoi bei metodi un'altra classe di nome Cartoleria() ora mi metto a scrivere un programma che fa uso di tali classi ma così come sono, posso ad esempio usare il metodo PagoBancomat() presente nella classe Negozianti() senza che io nel momento della fabbricazione delle classi Pizzeria() e Cartoleria() abbia messo il benchè minimo legame tra loro ? esempio: Pizzeria cliente = new Pizzeria(); cliente.PagoBancomat(); - posso fare così ?

Strumenti
Mostra una versione stampabile Invia questa pagina per email