summaryrefslogtreecommitdiffhomepage
path: root/it-it/java-it.html.markdown
diff options
context:
space:
mode:
authorJacob Ward <jacobward1898@gmail.com>2015-10-26 23:03:37 -0600
committerJacob Ward <jacobward1898@gmail.com>2015-10-26 23:03:37 -0600
commita0eb996415cc86cb72c44e793ebfacc3ec2d7b17 (patch)
tree516c83684b752f374758b9abd3b89be723478fd3 /it-it/java-it.html.markdown
parent66bc42e31bf62a1592f9b763e12c0b963b3e7d3d (diff)
parent44ca091c73afe13ec8760021cfed1d77afc5e4a5 (diff)
Merge remote-tracking branch 'adambard/master'
Diffstat (limited to 'it-it/java-it.html.markdown')
-rw-r--r--it-it/java-it.html.markdown170
1 files changed, 120 insertions, 50 deletions
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
index 6eabd61f..54602cff 100644
--- a/it-it/java-it.html.markdown
+++ b/it-it/java-it.html.markdown
@@ -6,6 +6,7 @@ contributors:
- ["Madison Dickson", "http://github.com/mix3d"]
translators:
- ["Ivan Sala","http://github.com/slavni96"]
+ - ["Tommaso Pifferi","http://github.com/neslinesli93"]
lang: it-it
---
@@ -31,9 +32,9 @@ import java.security.*;
// Ogni file .java contiene una classe pubblica, con lo stesso nome del file
public class LearnJava {
- // Un programma deve avere un metodo main come punto di partenza
- // Ma si possono creare anche file senza main, che perĂ² per essere usati
- // devono essere richiamati da altri file.
+ // Un programma deve avere un metodo main come punto di partenza.
+ // Tuttavia si possono creare anche file senza main, che perĂ²
+ // per essere usati devono essere richiamati da altri file.
public static void main (String[] args) {
// Per stampare a schermo si usa System.out.println
@@ -47,88 +48,157 @@ public class LearnJava {
System.out.print("Ciao ");
System.out.print("Mondo ");
+ // Per stampare del testo formattato, si puo' usare System.out.printf
+ System.out.printf("pi greco = %.5f", Math.PI); // => pi greco = 3.14159
///////////////////////////////////////
- // Tipi e Variabili
+ // Variabili
///////////////////////////////////////
- // Si dichiara una variabile usando <tipo> <nome>
- // Byte - variabile intera da 8 bit con segno
+
+ /*
+ * Dichiarazione delle Variabili
+ */
+ // Per dichiarare una variabile basta fare <tipoDato> <nomeVariabile>
+ int fooInt;
+ // Per dichiarare piu' di una variabile dello lo stesso tipo si usa:
+ // <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3>
+ int fooInt1, fooInt2, fooInt3;
+
+ /*
+ * Inizializzazione delle Variabili
+ */
+
+ // Per inizializzare una variabile si usa
+ // <tipoDato> <nomeVariabile> = <valore>
+ int fooInt = 1;
+ // Per inizializzare piu' di una variabile dello lo stesso tipo
+ // si usa <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3> = <valore>
+ int fooInt1, fooInt2, fooInt3;
+ fooInt1 = fooInt2 = fooInt3 = 1;
+
+ /*
+ * Tipi di Variabili
+ */
+ // Byte - intero con segno a 8 bit (in complemento a 2)
// (-128 <= byte <= 127)
byte fooByte = 100;
- // Short - variabile intera da 18 bit con segno
+ // Short - intero con segno a 16 bit (in complemento a 2)
// (-32,768 <= short <= 32,767)
short fooShort = 10000;
- // Integer - variabile intera da 32 bit con segno
+ // Integer - intero con segno a 32 bit (in complemento a 2)
// (-2,147,483,648 <= int <= 2,147,483,647)
int fooInt = 1;
- // Long - variabile da 64 bit intera con segno
+ // Long - intero con segno a 64 bit (in complemento a 2)
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L;
- // L viene usato per specificare che il valore dalla variabile
- // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata
- // e' trattata di base come un intero.
+ // L viene usato per indicare che il valore e' di tipo Long;
+ // altrimenti il valore viene considerato come intero.
- // Nota: Java non dispone di variabili senza segno
+ // Nota: Java non dispone di interi senza segno.
- // Float - variabile piu' precisa, con virgola [numeri reali]
- // di grandezza 32 bit
+ // Float - Numero in virgola mobile a 32 bit con precisione singola (IEEE 754)
+ // 2^-149 <= float <= (2-2^-23) * 2^127
float fooFloat = 234.5f;
- // f e' usato per specificare che la variabile e'' di tipo "float"
- // altrimenti di default viene trattata come un "dobule"
+ // f o F indicano the la variabile e' di tipo float;
+ // altrimenti il valore viene considerato come double.
- // Double - ancora piu' precisione la si puo' ottenere con una variabile
- // Double, con granzezza di 64 bit.
+ // Double - Numero in virgola mobile a 64 bit con precisione doppia (IEEE 754)
+ // 2^-1074 <= x <= (2-2^-52) * 2^1023
double fooDouble = 123.4;
- // Boolean - vero & falso
+ // Boolean - Puo' assumere il valore vero (true) o falso (false)
boolean fooBoolean = true;
boolean barBoolean = false;
- // Char - un singolo carattere con grandezza 16 bit
+ // Char - Un singolo carattere Unicode a 16-bit
char fooChar = 'A';
- // final - Costanti, non possono essere riassegnate ad un altro oggetto
- final int ORE_LAVORATIVE_DI_UNA_SETTIMANA = 9001;
-
- // String - Stringhe, array di caratteri
- String fooString = "Ecco una stringa!";
-
- // \n e' un carattere speciale che permette di andare a capo.
- String barString = "Andare a capo?\nNessun problema!";
- // \t e' un carattere speciale che permette di aggiungere un 'Tab'
- String bazString = "Vuoi inserire tab?\tNessun problema";
+ // Le variabili precedute da final possono essere inizializzate una volta sola,
+ final int HOURS_I_WORK_PER_WEEK = 9001;
+ // pero' e' possibile dichiararle e poi inizializzarle in un secondo momento.
+ final double E;
+ E = 2.71828;
+
+
+ // BigInteger - Interi a precisione arbitraria
+ //
+ // BigInteger e' un tipo di dato che permette ai programmatori di
+ // gestire interi piu' grandi di 64 bit. Internamente, le variabili
+ // di tipo BigInteger vengono memorizzate come un vettore di byte e
+ // vengono manipolate usando funzioni dentro la classe BigInteger.
+ //
+ // Una variabile di tipo BigInteger puo' essere inizializzata usando
+ // un array di byte oppure una stringa.
+
+ BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+
+ // BigDecimal - Numero con segno, immutabile, a precisione arbitraria
+ //
+ // Una variabile di tipo BigDecimal e' composta da due parti: un intero
+ // a precisione arbitraria detto 'non scalato', e un intero a 32 bit
+ // che rappresenta la 'scala', ovvero la potenza di 10 con cui
+ // moltiplicare l'intero non scalato.
+ //
+ // I BigDecimal permettono un controllo completo sull'arrotondamento
+ // dei numeri. Essi sono molto usati in ambito finanziario, nella
+ // gestione delle valute, e in ogni altro posto in cui serve
+ // precisione esatta.
+ //
+ // Le variabili di tipo BigDecimal possono essere inizializzate con un
+ // int, long, double o String, oppure con un intero non scalato
+ // (di tipo BigInteger) e una scala (int).
+
+ BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+
+
+ // Stringhe
+ String fooString = "Questa e' la mia stringa!";
+
+ // \n e' un carattere di escape che rappresenta l'andare a capo
+ String barString = "Stampare su una nuova riga?\nNessun problema!";
+ // \t e' un carattere di escape che aggiunge un tab
+ String bazString = "Vuoi aggiungere un tab?\tNessun problema!";
System.out.println(fooString);
System.out.println(barString);
System.out.println(bazString);
- // Vettori [array]
- //La lunghezza del vettore deve essere decisa quando viene istanziato
- //Si puo' dichiarare come segue:
- //<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>];
- //<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>];
- int [] intArray = new int[10];
- String [] stringArray = new String[1];
- boolean boolArray [] = new boolean[100];
-
- // Un altro modo per dichiarare & inizializzare un vettore
- int [] y = {9000, 1000, 1337};
- String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"};
+ // Vettori
+ // La dimensione di un array deve essere decisa in fase di
+ // istanziazione. Per dichiarare un array si puo' fare in due modi:
+ // <tipoDato>[] <nomeVariabile> = new <tipoDato>[<dimensioneArray>];
+ // <tipoDato> <nomeVariabile>[] = new <tipoDato>[<dimensioneArray>];
+ int[] intArray = new int[10];
+ String[] stringArray = new String[1];
+ boolean boolArray[] = new boolean[100];
+
+ // Un altro modo per dichiarare ed insieme inizializzare un vettore.
+ int[] y = {9000, 1000, 1337};
+ String names[] = {"Gianni", "Anna", "Luca", "Cristina"};
boolean bools[] = new boolean[] {true, false, false};
-
- // I vettori vengono indicizzati a parire dallo 0
+
+ // Per accedere ad un elemento di un vettore
System.out.println("intArray @ 0: " + intArray[0]);
- // e' possibile un accesso diretto ad un elemento
+ // I vettori non sono immutabili (ma la loro dimensione si!)
+ // e gli indici partono da 0.
intArray[1] = 1;
System.out.println("intArray @ 1: " + intArray[1]); // => 1
- // Altro da vedere:
- // Liste di array - come i vettori ma piu' funzionali
- // e la loro grandezza puo' variare in corso di esecuzione
- // Liste concatenate di memoria
+ // Ci sono altri tipo di dato interessanti.
+ // ArrayList - Simili ai vettori, pero' offrono altre funzionalita',
+ // e la loro dimensione puo' essere modificata.
+ // LinkedList - Si tratta di una lista linkata doppia, e come tale
+ // implementa tutte le operazioni del caso.
+ // Map - Un insieme di oggetti che fa corrispondere delle chiavi
+ // a dei valori. Non permette l'inserimento di chiavi uguali.
+ // HashMap - Questa classe usa una tabella di hash per implementare
+ // l'interfaccia di tipo Map. Questo permette di effettuare
+ // operazioni basilari, come inserimento e cancellazione,
+ // in tempo costante anche su insiemi molto grandi.
///////////////////////////////////////
// Operatori