Per la felicita di Dav82...JAVA!!

[Downloader]

Ho iniziato a fare un corso su Java, purtroppo essendo completamente a digiuno di questo linguaggio alcune cose che sono state spiegate non mi sono affatto chiare.

1) Cos'è l'interprete? L'interprete nel caso di Java è JVM? E nel caso del C?
2) Cos'è e come funziona il file *.class
3) Cos'è Javac?

Insomma...se potete darmi un po' di info generiche sopratutto per quanto riguarda la fase della complilazione e dell'esecuzione.

Tnx!!!

[Dav82]

Un altro adepto!

Originariamente inviato da Downloader
1) Cos'è l'interprete? L'interprete nel caso di Java è JVM? E nel caso del C?
2) Cos'è e come funziona il file *.class
3) Cos'è Javac?

1) I file .java non vengono compilati in codice macchina come i .c/.cpp, ma vengono tradotti in un formato intermedio detto bytecode, che viene dato in pasto ad un livello intermedio che si chiama interprete; per ogni sistema esiste un interprete Java, scritto in C (a quanto mi risulta per tutti i sistemi) e compilato per quel determinato sistema. L'interprete, ossia la Java Virtual Machine, elabora il bytecode e interpreta (da qui il nome di interprete e linguaggio interpretato) i comandi presenti traducendoli in codice che può girare sul particolare sistema.
2) Ma che cos'è, in buona sostanza, sto bytecode? I file .class sono proprio quei file che vengono dati in pasto alla JVM!
3) Ma come vengono generati i .class a partire dai .java, i file sorgenti che scrivi con il tuo ambiente di sviluppo? Con Javac, che è il Java Compiler della Sun. Ogni IDE poi utilizza questo compilatore integrato nell'ambiente, rendendo trasparante al programmatore la chiamata di javac.

Alla fine della fiera il processo si svolge così:

File .java -> (JavaC) file .class [bytecode] -> (JVM) esecuzione

La JVM può essere chiamata semplicemente con il comando "java nomefile", dove nomefile è il nome del file .class (ma senza estensione) che contiene il main del tuo programma.

Con Java hai anche il concetto di portabilità: mentre scrivendo programmi in C/C++ usi delle funzioni proprie di un determinato sistema, e una volta che hai compilato i file in codice macchina li puoi usare solo su quel sistema (da qui i programmi con versioni differenti per win/linux/mac ecc ecc), con Java puoi "compilare" i tuoi file ottenendo i .class, e questi .class possono essere dati in pasto a una qualsiasi JVM operante su qualsiasi sistema (nb: con beneficio d'inventario eh ): i .class sono quindi portabili.
Ovviamente c'è il rovescio della medaglia: un linguaggio interpretato come Java è molto più lento rispetto ad un linguaggio compilato come il C/C++, dovendo - in fase di esecuzione - operare una conversione al volo da bytecode a codice eseguibile.

Bye

[Downloader]

Gia decisamente piu chiaro (Y)

Ora vado a studiarmi tutti gli altri appunti

[LoryOne]

Bella domanda questa perchè a risponderti dovremmo esserci in parecchi.
Io cercherò di spiegare la cosa in modo semplice ed intuitivo.

La differenza tra compilatore ed interprete può essere spiegata agrandi linee in questo modo:
Supponi:
1- che ci siano due persone che debbano colloquiare tra loro e che la prima parli italiano mentre la seconda russo.
2- che la prima persona (A) debba impartire ordini alla seconda [B]
3- che la prima persona (A) non sappia nulla di russo

Affinchè la persona (A) possa farsi capire dalla persona [B], è necessario che la prima si appoggi ad un traduttore che trasformi l'italiano in russo, quindi ha bisogno di un interprete (C).
A questo punto non vi è ancora distinzione tra compilatore ed interprete perchè questa fase è comune ad entrambi.

Se (A) parlasse a [B] attraverso (C) in modo che (C) traducesse istantaneamente parola per parola gli ordini di (A) a [B], questo approccio sarebbe interpretato.
Negli interpreti, infatti, il codice viene eseguito sequenzialmente istruzione dopo istruzione in runtime. Ogni istruzione verrebbe quindi tradotta in codice macchina ed immediatamente eseguita.

Se invece (A) parlasse a [B] attraverso una lettera già tradotta da (C) nel linguaggio madre di [B] e a questa consegnata direttamente, a [B] basterebbe leggerla una volta per capire immediatamente tutti gli ordini impartiti da (A) ed eseguire velocemente.
In pratica la traduzione verrebbe eseguita tutta in una volta nel linguaggio comprensibile dal destinatario e questo approccio sarebbe compilato.

Alla luce di quanto sopra esposto risulta chiaro che più ci si avvicina al linguaggio macchina durante la fase di imposizione di direttive, tanto più veloce sarà il PC ad eseguire il compito assegnatogli.

Nel corso degli anni, la disparità di prestazioni tra codice interpretato e compilato si è andata via via restringendo, anche se il divario risulta e risulterà sempre e comunque a favore dei compilatori.

[Dav82]

Lory (Y)


(ogni tanto fa anche il serio questo ragazzo! )

[LoryOne]

Sono affetto da bug

[ceccus]

Salve,
Tutto giusto...aggiungo soltanto che , ormai da molto tempo, sia la JVM che la VM di Microsoft, "compilano" al volo il codice intermedio (compilazione JiT = Just in Time) e "se lo mettono da parte", pronto per essere "ripesacto" nel caso che venisse rieseguito...
In questo modo , il primo che lancia l'applicazione "paga" in termini prestazionali, tutti gli altri no....ed è questo che ha , di fatto, decretato "il risveglio" dei linguaggi interpretati.....

Ciao !!

[Downloader]

Qualche spiegaziocina:
1) Cos'è il costructor
2) Cos'è il mutator
3) Nell'UML cosa rappresentano le linee tratteggiate e i rombi biachi e neri?

Tnx!

[Dav82]

Originariamente inviato da Downloader
1) Cos'è il costructor

Il constructor, o costruttore (in italiano), è - se vuoi - un "metodo speciale" che permette di creare un'istanza di una classe. La classe è un'entità astratta, il cui codice viene scritto dal programmatore: di ogni classe si possono avere più istanze, ognuna ottenuta tramite un'opportuna invocazione di uno dei metodi costruttori della classe (ebbene sì, una classe può avere anche più di un costruttore).
Per esempio, in un'applicazione per il gioco della dama, ci sarà la classe Pedina, e orientativamente ci saranno 15 istanze di Pedina per il bianco e altre 15 per il nero. Il costruttore è un metodo come gli altri, nel senso che prevede la presenza di parametri, e come risultato dà il riferimento all'oggetto creato.

Originariamente inviato da Downloader
2) Cos'è il mutator

Qua, se vogliamo fare le cose con un po' di rigore, andiamo più sul complicato. Ogni oggetto, inteso come istanza di una classe (e come cacchio si può intendere altrimenti! ), ha uno stato proprio; questo stato è definito dall'insieme dei valori che in un dato momento sono assunti dagli attributi dell'oggetto stesso. Per esempio, sempre con riferimento alla Pedina di cui sopra, ci potranno essere degli attributi quali

int x; //la coordinata x in cui si trova la pedina
int y; //la coord y
boolean vivo;//false se mangiato dall'avversario

Lo stato di una pedina può essere, ad esempio, {2, 4, true} (e non fare le pulci che le coordinate sono del tipo (lettera, numero)! ).
Un metodo mutator (o modificatore in italiano) è un metodo che permette di cambiare lo stato di un oggetto. Per esempio può esserci il metodo

muoviAvanti(){
   this.y += 1;
}

che, come vedi, cambia lo stato dell'oggetto Pedina su cui è stato invocato il metodo muoviAvanti. Ovviamente il metodo può prendere, a seconda della semantica ad esso associata, dei parametri (in questo caso no, ma per esempio pensa ad un oggetto ContoBancario con il metodo preleva(int prelievo)).

Un piccolo esempio!

public class ContoBancario{

   int saldo = 0;
   String nomeCorrentista = "";
   String cognomeCorrentista = "";
   int operazioni = 0;

   public ContoBancario (String nome, String cognome){
      this.nomeCorrentista = nome;
      this.cognomeCorrentista = cognome;
   }

   /**
    *Questo metodo è un OBSERVER (osservatore) poichè non modifica lo stato dell'oggetto
   */
   public int saldo saldo(){
      return this.saldo;
   }

   /**
    *prelievo => (ammontare < 0), deposito => (ammontare > 0)
    */
   public void movimento(int ammontare) throws ContoInRossoException{
      
      if ((saldo + ammontare) < 0)
         throw new ContoInRossoException("Stai al verde!");
      
      this.saldo += ammontare;
   }
}

e questo è un possibile main per utilizzare sta classe:

public class Downloader(){

    public static void main(String[] args){
    
       contoBancario bg = new ContoBancario("Guglielmo", "Cancelli);
       System.out.println("Saldo di Bill: " + bg.saldo());
       bg.movimento(1000000);
       bg.movimento(-5000);
       System.out.println("Saldo di Bill dopo 10 WinMe: " + bg.saldo());
    }
}

E' un codice assolutamente stupido e schifoso, ma solo per rendere l'idea.
Se stai studiando sul libro della Barbara Liskov, ti sarai accorto che nel metodo movimento c'è il controllo affinché il conto non vada in rosso, e questo equivale a garantire che il RepInvariant (invariante di rappresentazione), dato molto probabilmente dalle condizioni {nomeCorrentista != null AND cognomeCorrentista != null AND saldo >= 0}, sia verificato.

Originariamente inviato da Downloader
3) Nell'UML cosa rappresentano le linee tratteggiate e i rombi biachi e neri?

Secondo la versione di UML che uso io con Poseidon le linee tratteggiate indicano la realizzazione di un'interfaccia, ossia collegano un'interfaccia con una classe che implementa l'interfaccia stessa. Però non penso che sia questo lo standard... per i rombi non saprei, ormai ho visto 3 "standard" UML diversi... se però non ne veniamo a capo, riapro il mio UML Distilled


Spero che il codice sia abbastanza chiaro

[Downloader]

Aspe, siccome io per il momento non ho mai buttato giu una riga di codice mo mi trovo un po' spiazzato.

Ho dei dubbi riguardo la scrittura di un metodo generico e di quelli set, get o costruttore (che poi dovrebbero essere scritti allo stesso modo, o sbalgio?

Ad ogni modo allego qualche righetta di codice, potete controllare se è scritta nel modo corretto visto che dal pc in cui scrivo non ho un compilatore?
tnx!

// Dichiarazione di una classe 
public class Javajava
{
  public metodoGenerico (/*argomenti*/)
   {
   	// codice
   	
   	// va alla fine il return, e se si a che serve?
   	
   }
  
  // Questo è il main, ovvero l'entry point della jvm
  public static void main(String[] args)
  {
    System.out.println("Javaaaaaaa"); 	
 	
  }
	
}

[Dav82]

Originariamente inviato da Downloader
Aspe, siccome io per il momento non ho mai buttato giu una riga di codice mo mi trovo un po' spiazzato.

Enno no no no!
Appena si studia una roba, bisogna metterla in pratica, tanto più con lo studio di un linguaggio di programmazione: prove stupide, che non servono a niente, ma da fare

Ho dei dubbi riguardo la scrittura di un metodo generico e di quelli set, get o costruttore (che poi dovrebbero essere scritti allo stesso modo, o sbalgio?

Esattamente. Tutti i metodi hanno la stessa struttura:

<modificatore>* <tipo_ritornato> <nome_metodo> ( <argomenti> )

dove "*" significa: zero o più (anche se la cosa è un tantino più complicata)

  public metodoGenerico (/*argomenti*/)
   {
   	// codice   	
   	// va alla fine il return, e se si a che serve?
   	
   }

Ogni metodo deve avere il tipo di ritorno: se non ritorna nulla, devi comunque mettere void, altrimenti il compilatore fa lo schizzinoso

Per i modificatori, quali private, public, static... puoi metterli come non metterli, il compilatore interpreterà l'assenza di modificatori come il modificatore di default, ma questo non può essere fatto per il tipo ritornato.
Tutto il resto è corretto.

visto che dal pc in cui scrivo non ho un compilatore?

SACRILEGIO!

In ogni computer deve esserci un compilatore Java!

[Downloader]

Scusa un altra cosa:

quando voglio salvare un valore che inserisco in input col c++ uso il comando cin, in java che comando c'è?

[Downloader]

ULTRA URGENTE!!

Ho bisogno di un consiglio su un buon libro per Java (i suoi fondamenti) che avete magari anche usato e con il quale vi siete trovati bene.

Se avesse anche un po' di esempi sarebbe anche meglio.

Io anche se un po' di fretta ne avevo notato una della Apogeo con copertina blu che non mi pareva malaccio.

[Dav82]

Io ho usato il Thinking in Java, di Bruce Eckel, lo puoi trovare su internet con Google, il file si chiama TIJ3.pdf o qualcosa del genere Unica cosa è che è in inglese

Per il resto ho visto i Deitel & Deitel, il libro base e quello avanzato... quello base è più che altro per chi non sa cos'è un ciclo e simili, è proprio molto di base... mentre il secondo ha qualche aspetto più interessante.
Secondo me sono un po' pedanti con gli esempi, ma è un mio modo di vedere.

Altri non te ne saprei consigliare, non ne ho letti

[Downloader]

Azz, se non fosse per l'inglese!

Purtroppo avrei bisogno di un qualcosa in italiano che mi spieghi anche gli aspetti piu semplici del java perchè oggi mi sono accorto di non saperne proprio nulla

Tnx! Poi ti faro sapere!