info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-08-11 09:14:39 +02:00
Code Issues Releases Wiki Activity

Fixed all -> Final relase

Browse Source 
fixed names, italians sentencens, compile&exec things and so on.
now imho this can be merged.
This commit is contained in:
Ivan Sala
2014-02-27 17:05:26 +01:00
parent 06328316d1
commit 54c3e39237
1 changed files with 61 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
it-it/java.html.markdown
View File

@@ -15,13 +15,13 @@ Java è un linguaggio di programmazione orientato ad oggetti,
concorrente, basato su classi e adatto a svariati scopi. concorrente, basato su classi e adatto a svariati scopi.
[Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html) [Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html)
```java ```Java
// I commenti su singola linea incominciano con // // I commenti su singola linea incominciano con //
/* /*
I commenti su più linee invece sono così I commenti su piu' linee invece sono cosi'
*/ */
/** /**
I commenti per la documentazione JavaDoc si fanno così. I commenti per la documentazione JavaDoc si fanno cosi'.
Vengono usati per descrivere una classe o alcuni suoi attributi. Vengono usati per descrivere una classe o alcuni suoi attributi.
*/ */
@@ -34,6 +34,8 @@ import java.security.*;
public class LearnJava { public class LearnJava {
// Un programma deve avere un metodo main come punto di partenza // 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.
public static void main (String[] args) { public static void main (String[] args) {
// Per stampare a schermo si usa System.out.println // Per stampare a schermo si usa System.out.println
@@ -43,9 +45,9 @@ public class LearnJava {
" Reale [double]: " + 3.14 + " Reale [double]: " + 3.14 +
" Booleano [boolean]: " + true); " Booleano [boolean]: " + true);
// Se non si vuole andare a capo, si può usare System.out.print // Se non si vuole andare a capo, si puo' usare System.out.print
System.out.print("Ciao "); System.out.print("Ciao ");
System.out.print("Mondo"); System.out.print("Mondo ");
/////////////////////////////////////// ///////////////////////////////////////
@@ -68,18 +70,18 @@ public class LearnJava {
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L; long fooLong = 100000L;
// L viene usato per specificare che il valore dalla variabile // L viene usato per specificare che il valore dalla variabile
// è di tipo "Long", qualsiasi variabile che non viene contrassegnata // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata
// è trattata di base come un intero. // e' trattata di base come un intero.
// Nota: Java non dispone di variabili senza segno // Nota: Java non dispone di variabili senza segno
// Float - variabile più precisa, con virgola [numeri reali] // Float - variabile piu' precisa, con virgola [numeri reali]
// di grandezza 32 bit // di grandezza 32 bit
float fooFloat = 234.5f; float fooFloat = 234.5f;
// f è usato per specificare che la variabile è di tipo "float" // f e' usato per specificare che la variabile e'' di tipo "float"
// altrimenti da default viene trattata come "dobule" // altrimenti di default viene trattata come un "dobule"
// Double - ancora più precisione la si può ottenere con una variabile // Double - ancora piu' precisione la si puo' ottenere con una variabile
// Double, con granzezza di 64 bit. // Double, con granzezza di 64 bit.
double fooDouble = 123.4; double fooDouble = 123.4;
@@ -93,12 +95,12 @@ public class LearnJava {
// final - Costanti, non possono essere riassegnate ad un altro oggetto // final - Costanti, non possono essere riassegnate ad un altro oggetto
final int HOURS_I_WORK_PER_WEEK = 9001; final int HOURS_I_WORK_PER_WEEK = 9001;
// String - Stringhe, array di caratteri (char) // String - Stringhe, array di caratteri
String fooString = "Ecco una stringa!"; String fooString = "Ecco una stringa!";
// \n è un carattere speciale che permette di andare a capo. // \n e' un carattere speciale che permette di andare a capo.
String barString = "Printing on a new line?\nNo Problem!"; String barString = "Printing on a new line?\nNo Problem!";
// \t è un carattere speciale che permette di aggiungere un 'Tab' // \t e' un carattere speciale che permette di aggiungere un 'Tab'
String bazString = "Do you want to add a tab?\tNo Problem!"; String bazString = "Do you want to add a tab?\tNo Problem!";
System.out.println(fooString); System.out.println(fooString);
System.out.println(barString); System.out.println(barString);
@@ -106,7 +108,7 @@ public class LearnJava {
// Vettori [array] // Vettori [array]
//La lunghezza del vettore deve essere decisa quando viene istanziato //La lunghezza del vettore deve essere decisa quando viene istanziato
//Si può dichiarare come segue: //Si puo' dichiarare come segue:
//<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>]; //<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>];
//<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>]; //<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>];
int [] intArray = new int[10]; int [] intArray = new int[10];
@@ -118,17 +120,16 @@ public class LearnJava {
String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"};
boolean bools[] = new boolean[] {true, false, false}; boolean bools[] = new boolean[] {true, false, false};
// Accesso diretto ad un elemento // I vettori vengono indicizzati a parire dallo 0
System.out.println("intArray @ 0: " + intArray[0]); System.out.println("intArray @ 0: " + intArray[0]);
// I vettori vengono indicizzati a parire dallo 0 // e' possibile un accesso diretto ad un elemento
// Ma questo indice può essere cambiato.
intArray[1] = 1; intArray[1] = 1;
System.out.println("intArray @ 1: " + intArray[1]); // => 1 System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Altro da vedere: // Altro da vedere:
// Liste di array - come i vettori ma più funzionali // Liste di array - come i vettori ma piu' funzionali
// e la loro grandezza può variare in corso di esecuzione // e la loro grandezza puo' variare in corso di esecuzione
// Liste concatenate di memoria // Liste concatenate di memoria
/////////////////////////////////////// ///////////////////////////////////////
@@ -138,7 +139,7 @@ public class LearnJava {
int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea
// L'aritmetica è lineare. // L'aritmetica e' lineare.
System.out.println("1+2 = " + (i1 + i2)); // => 3 System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1 System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2 System.out.println("2*1 = " + (i2 * i1)); // => 2
@@ -184,7 +185,7 @@ public class LearnJava {
/////////////////////////////////////// ///////////////////////////////////////
System.out.println("\n->Strutture di controllo"); System.out.println("\n->Strutture di controllo");
// La dichiarazione dell'If è C-like. // La dichiarazione dell'If e'' C-like.
int j = 10; int j = 10;
if (j == 10){ if (j == 10){
System.out.println("Io vengo stampato"); System.out.println("Io vengo stampato");
@@ -239,7 +240,7 @@ public class LearnJava {
// Struttura Switch Case // Struttura Switch Case
// La struttura switch lavora con byte, short, char e int. // La struttura switch lavora con byte, short, char e int.
// Se funziona con i char funzionerà ovviamente anche con le stringhe. // Se funziona con i char funzionera ovviamente anche con le stringhe.
int mese = 3; int mese = 3;
String stringaMese; String stringaMese;
switch (mese){ switch (mese){
@@ -247,7 +248,7 @@ public class LearnJava {
stringaMese = "Genneio"; stringaMese = "Genneio";
break; break;
case 2: case 2:
strigaMese = "Febbraio"; stringaMese = "Febbraio";
break; break;
case 3: case 3:
stringaMese = "Marzo"; stringaMese = "Marzo";
@@ -256,16 +257,17 @@ public class LearnJava {
stringaMese = "Altri mesi"; stringaMese = "Altri mesi";
break; break;
} }
System.out.println("Risultato del costrutto switch:: " + stringaMese); System.out.println("Risultato del costrutto switch: " + stringaMese);
// Condizioni brevi // Condizioni brevi
// Si può usare l'operatore '?' per un rapido assegnamento // Si puo' usare l'operatore '?' per un rapido assegnamento
// o per operazioni logiche. // o per operazioni logiche.
// Si legge: // Si legge:
// Se (condizione) è vera, usa <primo valore>, altrimenti usa <secondo valore> // Se (condizione) e' vera, usa <primo valore>, altrimenti usa <secondo valore>
int foo = 5; int foo = 5;
String bar = (foo < 10) ? "A" : "B"; String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Stampa A, perchè la condizione è vera. System.out.println("Se la condizione e' vera stampa A: "+bar);
// Stampa A, perche' la condizione e' vera.
///////////////////////////////////////// /////////////////////////////////////////
@@ -300,10 +302,10 @@ public class LearnJava {
// (Di seguito la definizione della classe Bicicletta) // (Di seguito la definizione della classe Bicicletta)
// Instanziare una nuova classe // Instanziare una nuova classe
Bicicletta perocorso = new Bicicletta(); Bicicletta percorso = new Bicicletta();
// Chiamare metodi // Chiamare metodi
perorso.velocità(3); // Si usano sempre metodi set... get... percorso.accellera(3); // Si usano sempre metodi set... get...
percorso.setCadenza(100); percorso.setCadenza(100);
// toString riporta la rappresenzazione dell'oggetto // toString riporta la rappresenzazione dell'oggetto
@@ -327,28 +329,28 @@ class Bicicletta {
// Variabili della bicicletta // Variabili della bicicletta
public int cadenza; public int cadenza;
// Public: Può essere richiamato da qualsiasi classe // Public: Puo' essere richiamato da qualsiasi classe
private int velocità; private int velocita;
// Private: è accessibile solo dalla classe dove è stato inizializzato // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato
protected int ingranaggi; protected int ingranaggi;
// Protected: è visto sia dalla classe che dalle sottoclassi // Protected: e'' visto sia dalla classe che dalle sottoclassi
String nome; String nome;
// default: è accessibile sono all'interno dello stesso package // default: e'' accessibile sono all'interno dello stesso package
// I costruttori vengono usati per creare variabili // I costruttori vengono usati per creare variabili
// Questo è un costruttore // Questo e'' un costruttore
public Bicicletta() { public Bicicletta() {
ingranaggi = 1; ingranaggi = 1;
cadenza = 50; cadenza = 50;
velocità = 5; velocita = 5;
nome = "Bontrager"; nome = "Bontrager";
} }
// Questo è un costruttore che richiede parametri // Questo e'' un costruttore che richiede parametri
public Bicicletta(int cadenzaIniziale, int velocitàIniziale, int ingranaggiIniziali, String nome) { public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) {
this.ingranaggi = ingranaggiIniziali; this.ingranaggi = ingranaggi;
this.cadenza = CadenzaIniziale; this.cadenza = cadenza;
this.velocità = VelocitàIniziale; this.velocita = velocita;
this.nome = nome; this.nome = nome;
} }
@@ -374,11 +376,11 @@ class Bicicletta {
} }
public void accellera(int incrementa) { public void accellera(int incrementa) {
velocità += incrementa; velocita += incrementa;
} }
public void decellera(int decrementa) { public void decellera(int decrementa) {
velocità -= decrementa; velocita -= decrementa;
} }
public void setNome(String nuovoNome) { public void setNome(String nuovoNome) {
@@ -394,24 +396,24 @@ class Bicicletta {
public String toString() { public String toString() {
return "Ingranaggi: " + ingranaggi + return "Ingranaggi: " + ingranaggi +
" Cadenza: " + cadenza + " Cadenza: " + cadenza +
" Velocità: " + velocità + " Velocita: " + velocita +
" Nome: " + nome; " Nome: " + nome;
} }
} // Fine classe bicicletta } // Fine classe bicicletta
// PennyFarthing è una sottoclasse della bicicletta // PennyFarthing e'' una sottoclasse della bicicletta
class PennyFarthing extends Bicicletta { class PennyFarthing extends Bicicletta {
// (Sono quelle biciclette con un unica ruota enorme // (Sono quelle biciclette con un unica ruota enorme
// Non hanno ingranaggi.) // Non hanno ingranaggi.)
public PennyFarthing(int cadenzaIniziale, int velocitàIniziale){ public PennyFarthing(int cadenzaIniziale, int velocitaIniziale){
// Richiamo il costruttore del padre con super // Richiamo il costruttore del padre con super
super(cadenzaIniziale, velocitàIniziale, 0, "PennyFarthing"); super(cadenzaIniziale, velocitaIniziale, 0, "PennyFarthing");
} }
// Bisogna contrassegnre un medodo che si sta riscrivendo // Bisogna contrassegnre un medodo che si sta riscrivendo
// con una @annotazione // con una @annotazione
// Per saperne di più sulle annotazioni // Per saperne di piu' sulle annotazioni
// Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/
@Override @Override
public void setIngranaggi(int ingranaggi) { public void setIngranaggi(int ingranaggi) {
@@ -419,27 +421,26 @@ class PennyFarthing extends Bicicletta {
} }
} }
/*
//Interfacce //Interfacce
//Sintassi per dichiarare una interfaccia //Sintassi per dichiarare una interfaccia
//<livello di accesso> interface <nome dell'interfaccia> extends <super-interfaccia> { //<livello di accesso> interface <nome dell'interfaccia> extends <super-interfaccia> {
// //Costanti // //Costanti
// //Dichiarazioni dei metodi // //Dichiarazioni dei metodi
//} //}
//Esempi- Cibo: //Esempi- Cibo:
public interface Commestribile { interface Commestibile {
public void mangia(); public void mangia();
//Ogni classe che implementa questa interfaccia //Ogni classe che implementa questa interfaccia
//deve implementare questo metodo. //deve implementare questo metodo.
} }
interface Digeribile {
public interface Digestibile {
public void digerisci(); public void digerisci();
} }
//Possiamo quindi creare una classe che implementa entrambe le interfaccie //Possiamo quindi creare una classe che implementa entrambe le interfaccie
public class Frutta implements Edible, Digestible { class Frutta implements Commestibile, Digestibile {
public void mangia() { public void mangia() {
//... //...
} }
@@ -449,9 +450,9 @@ public class Frutta implements Edible, Digestible {
} }
} }
//In Java si può estendere solo una classe, ma si possono implementare //In Java si puo' estendere solo una classe, ma si possono implementare
//più interfaccie, per esempio: //piu' interfaccie, per esempio:
public class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia { class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia {
public void MetodoPrimaInterfaccia() { public void MetodoPrimaInterfaccia() {
} }
@@ -460,9 +461,8 @@ public class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, Seco
} }
} }
*/
``` ```
## Letture future ## Letture future
I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici
@@ -502,5 +502,3 @@ I link di seguito sono solo per capire l'argomento, cerca pure su Google degli e
* [Thinking in java](http://www.amazon.it/Thinking-Java-1-Bruce-Eckel/dp/8871923030/ref=sr_1_8?ie=UTF8&qid=1393422296&sr=8-8&keywords=java) * [Thinking in java](http://www.amazon.it/Thinking-Java-1-Bruce-Eckel/dp/8871923030/ref=sr_1_8?ie=UTF8&qid=1393422296&sr=8-8&keywords=java)
* [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300) * [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300)