From 4c579c9a6c5cebe0ee4fe8bfa96da6fce02d2d49 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Tue, 25 Feb 2014 17:30:02 +0100 Subject: Java - Added Italian [it-it] translation -> First relase --- it-it/java.html.markdown | 500 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 500 insertions(+) create mode 100644 it-it/java.html.markdown (limited to 'it-it/java.html.markdown') diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown new file mode 100644 index 00000000..76e0f027 --- /dev/null +++ b/it-it/java.html.markdown @@ -0,0 +1,500 @@ +--- + +language: java +filename: LearnJava.java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Madison Dickson", "http://github.com/mix3d"] +translators: + - ["Ivan Sala","http://github.com/dev-sala"] +lang: it-it + +--- +Java è un linguaggio di programmazione orientato ad oggetti, +concorrente, basato su classi e adatto a svariati scopi. +[Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html) + +```java +// I commenti su singola linea incominciano con // +/* +I commenti su più linee invece sono così +*/ +/** +I commenti per la documentazione JavaDoc si fanno così. +Vengono usati per descrivere una classe o alcuni suoi attributi. +*/ + +// Per importare la classe ArrayList conenuta nel package java.util +import java.util.ArrayList; +// Per importare tutte le classi contenute nel package java.security +import java.security.*; + +// Ogni filce .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 + public static void main (String[] args) { + + // Per stampare a schermo si usa System.out.println + System.out.println("Hello World!"); + System.out.println( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Se non si vuole andare a capo, si può usare System.out.print + System.out.print("Hello "); + System.out.print("World"); + + + /////////////////////////////////////// + // Tipi e Variabili + /////////////////////////////////////// + // Si dichiara una variabile usando + // Byte - 8-bit signed two's complement integer + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - 16-bit signed two's complement integer + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - 32-bit signed two's complement integer + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // Long - 64-bit signed two's complement integer + // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + long fooLong = 100000L; + // L is used to denote that this variable value is of type Long; + // anything without is treated as integer by default. + + // Nota: Java non dispone di variabili senza segno + + // Float - Single-precision 32-bit IEEE 754 Floating Point + float fooFloat = 234.5f; + // f is used to denote that this variable value is of type float; + // otherwise it is treated as double. + + // Double - Double-precision 64-bit IEEE 754 Floating Point + double fooDouble = 123.4; + + // Boolean - true & false + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - A single 16-bit Unicode character + char fooChar = 'A'; + + // final - Costanti, non possono essere riassegnate ad un altro oggetto + final int HOURS_I_WORK_PER_WEEK = 9001; + + // Stringhe + String fooString = "My String Is Here!"; + + // \n è un carattere speciale che permette di andare a capo. + String barString = "Printing on a new line?\nNo Problem!"; + // \t è un carattere speciale che permette di aggiungere un 'Tab' + String bazString = "Do you want to add a tab?\tNo Problem!"; + System.out.println(fooString); + System.out.println(barString); + System.out.println(bazString); + + // Vettori + //La lunghezza del vettore deve essere decisa quando viene istanziato + //Si può dichiarare come segue: + // [] = new []; + // [] = new []; + 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 names [] = {"Bob", "John", "Fred", "Juan Pedro"}; + boolean bools[] = new boolean[] {true, false, false}; + + // Accesso diretto ad un elemento + System.out.println("intArray @ 0: " + intArray[0]); + + // I vettori vengono indicizzati a parire dallo 0, ma sono mutabili + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // Altro da aggiungere: + // Liste di array - come i vettori ma vi sono più funzioni + // e la grandezza può variare in corso di esecuzione + // Liste concatenate + // Maps + // HashMaps + + /////////////////////////////////////// + // Operatori + /////////////////////////////////////// + System.out.println("\n->Operatori"); + + int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea + + // L'aritmetica è lineare. + System.out.println("1+2 = " + (i1 + i2)); // => 3 + System.out.println("2-1 = " + (i2 - i1)); // => 1 + System.out.println("2*1 = " + (i2 * i1)); // => 2 + System.out.println("1/2 = " + (i1 / i2)); // => 0 + // (con 0.5 arrotonda per difetto) + + // Modulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Operatori di confronto + System.out.println("3 == 2? " + (3 == 2)); // => falso + System.out.println("3 != 2? " + (3 != 2)); // => vero + System.out.println("3 > 2? " + (3 > 2)); // => vero + System.out.println("3 < 2? " + (3 < 2)); // => falso + System.out.println("2 <= 2? " + (2 <= 2)); // => vero + System.out.println("2 >= 2? " + (2 >= 2)); // => vero + + // Bitwise operators! + // Operatori binari + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed right shift + >>> Unsigned right shift + & AND Binario Bitwise AND + ^ OR Esclusivo + | OR Incusivo + */ + + // Incrementare + int i = 0; + System.out.println("\n->Incrementare/Decrementare"); + // Gli operatori ++ e -- incrementano e decrementano ripettivamente di 1. + // Se posizionati prima della variabile, incrementano, quindi riportano. + // Se si trovano dopo la variabile, riporano, e quindi incrementano. + System.out.println(i++); //i = 1, Stampa 0 (post-incremento) + System.out.println(++i); //i = 2, Stampa 2 (pre-incremento) + System.out.println(i--); //i = 1, Stampa 2 (post-decremento) + System.out.println(--i); //i = 0, Stampa 0 (pre-decremento) + + /////////////////////////////////////// + // Strutture di controllo + /////////////////////////////////////// + System.out.println("\n->Strutture di controllo"); + + // La dichiarazione dell'If è C-like. + int j = 10; + if (j == 10){ + System.out.println("Io vengo stampato"); + } else if (j > 10) { + System.out.println("Io no"); + } else { + System.out.println("E io neppure"); + } + + // Struttura While + int fooWhile = 0; + while(fooWhile < 100) + { + //System.out.println(fooWhile); + //Incrementa il contatore + //Si ripete per 100 volte, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("Valore di fooWhile: " + fooWhile); + + // Struttura Do While + int fooDoWhile = 0; + do + { + //System.out.println(fooDoWhile); + //Incrementa il contaore + //Si repete per 99 volte, fooDoWhile 0->99 + fooDoWhile++; + }while(fooDoWhile < 100); + System.out.println("Valore di fooWhile: " + fooDoWhile); + + // Struttura For + int fooFor; + //Struttura For => for(; ; ) + for(fooFor=0; fooFor<10; fooFor++){ + //System.out.println(fooFor); + //Itera 10 volte, fooFor 0->9 + } + System.out.println("Valore di fooFor: " + fooFor); + + // Struttura For Each + // Una iterazione automatica attraverso un array o una lista di oggetti + int[] fooList = {1,2,3,4,5,6,7,8,9}; + //struttura for each => for( : ) + //si legge: per ogni oggetto dell'array fai... + //Nota: il tipo dell'oggetto deve essere uguale a quello dell'array + + for( int bar : fooList ){ + //System.out.println(bar); + //Itera 9 volte e stampa 1-9 andando a capo. + } + + // Struttura Switch Case + // La struttura switch lavora con byte, short, char e int. + // Se funziona con i char funzionerà ovviamente anche con le stringhe. + int mese = 3; + String stringaMese; + switch (mese){ + case 1: + stringaMese = "Genneio"; + break; + case 2: + strigaMese = "Febbraio"; + break; + case 3: + stringaMese = "Marzo"; + break; + default: + stringaMese = "Altri mesi"; + break; + } + System.out.println("Risultato del costrutto switch:: " + stringaMese); + + // Condizioni brevi + // Si può usare l'operatore '?' per un rapido assegnamento + // o per operazioni logiche. + // Si legge: + // Se (condizione) è vera, usa , altrimenti usa + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Stampa A, perchè la condizione è vera. + + + ///////////////////////////////////////// + // Convertire i tipi di tati e Typcasting + ///////////////////////////////////////// + + // Convertire tipi di dati + + // Stringhe ad interi + Integer.parseInt("123");//Riporta una versione intera di "123" + + // Interi a Stringhe + Integer.toString(123);//Riporta la stringa "123" + // Per altre conversioni guarda le seguenti classi + // Double + // Long + // String + + // Typecasting + // Vi sono molti dettagli che non si possono spiegare qui, + // java dispone di una ottima documentazione + // Sentiti libero di leggerla + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classi e funzioni + /////////////////////////////////////// + + System.out.println("\n->Classi & Funzioni"); + + // (Di seguito la definizione della classe Bicicletta) + + // Instanziare una nuova classe + Bicycle trek = new Bicycle(); + + // Chiamare metodi + trek.speedUp(3); // Si usano sempre metodi set... get... + trek.setCadence(100); + + // toString riporta la rappresenzazione dell'oggetto + // come se fosse una stringa + System.out.println("trek info: " + trek.toString()); + + } // Fine metodo main +} // Fine classe ImparareJavas + + +// Si possono inculdere altre anche delle classi non pubbliche (private) +// oltre a quella pubblica principale, in un file .java + +// Sintassi per dichiarare una classe: +// class { +// //dati, variabili, costruttori, funzioni, tutto qua. +// //le funzioni sono chiamate come i metodi. +// } + +class Bicicletta { + + // Variabili della bicicletta + public int cadence; + // Public: Può essere richiamato da qualsiasi classe + private int speed; + // Private: è accessibile solo dalla classe dove è stato inizializzato + protected int gear; + // Protected: è visto sia dalla classe che dalle sottoclassi + String name; + // default: è accessibile sono all'interno dello stesso package + + // I costruttori vengono usati per creare variabili + // Questo è un costruttore + public Bicicletta() { + ingranaggi = 1; + ritmo = 50; + velocità = 5; + nome = "Bontrager"; + } + + // Questo è un costruttore che richiede parametri + public Bicycle(int startCadence, int startSpeed, int startGear, String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // Sintassi delle funzioni: + // () + + // Le classi in java spesso implementano delle funzioni o metodo + // 'get...' o 'set...' + + // Dichiarazione di un metodo + // () + public int getCadence() { + return cadence; + } + + // i medodi (void) non necessitano di riportare un valore + public void setCadence(int newValue) { + cadence = newValue; + } + + public void setGear(int newValue) { + gear = newValue; + } + + public void speedUp(int increment) { + speed += increment; + } + + public void slowDown(int decrement) { + speed -= decrement; + } + + public void setName(String newName) { + name = newName; + } + + public String getName() { + return name; + } + + //Medoto per visualizzare gli attributi dell'oggetto + @Override + public String toString() { + return "gear: " + gear + + " cadence: " + cadence + + " speed: " + speed + + " name: " + name; + } +} // Fine classe bicicletta + +// PennyFarthing è una sottoclasse della bicicletta +class PennyFarthing extends Bicycle { + // (Sono quelle biciclette con un unica ruota enorme + // Non hanno ingranaggi.) + + public PennyFarthing(int startCadence, int startSpeed){ + // Richiamo il costruttore del padre con super + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // You should mark a method you're overriding with an @annotation + // Bisogna contrassegnre un medodo che si sta riscrivendo + // con una @annotazione + // Per saperne di più sulle annotazioni + // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } + +} + +//Interfaccie +//Sintassi per dichiarare una interfaccia +// interface extends { +// //Constants +// //Method declarations +//} + +//Example - Food: +public interface Edible { + public void eat(); //Any class that implements this interface, must implement this method +} + +public interface Digestible { + public void digest(); +} + +//Possiamo quindi creare una classe che implementa entrambe le interfaccie +public class Fruit implements Edible, Digestible { + public void eat() { + //... + } + + public void digest() { + //... + } +} + +//In Java si può estendere solo una classe, ma si possono implementare +//più interfaccie, per esempio: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { + public void InterfaceOneMethod() { + + } + + public void InterfaceTwoMethod() { + + } +} + +``` + +## Letture future + +I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici + +**Guida ufficiale di Oracle**: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) + +* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) + +* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) + +**Tutorial Online** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Libri**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) + +* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300) + + -- cgit v1.2.3 From ccf61c677944ee2f925e4b6a8ee3e25856287281 Mon Sep 17 00:00:00 2001 From: Ivan Sala Date: Wed, 26 Feb 2014 15:27:10 +0100 Subject: Updated links and other -> Middle relase [java/it-it] - Java translation * Completed general translation. * Updated all link with italian's one. * Fixed some errors. --- it-it/java.html.markdown | 93 +++++++++++++++++++++++++----------------------- 1 file changed, 49 insertions(+), 44 deletions(-) (limited to 'it-it/java.html.markdown') diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown index 76e0f027..afd41af5 100644 --- a/it-it/java.html.markdown +++ b/it-it/java.html.markdown @@ -10,6 +10,7 @@ translators: lang: it-it --- + Java è un linguaggio di programmazione orientato ad oggetti, concorrente, basato su classi e adatto a svariati scopi. [Per saperne di più](http://docs.oracle.com/javase/tutorial/java/index.html) @@ -29,7 +30,7 @@ import java.util.ArrayList; // Per importare tutte le classi contenute nel package java.security import java.security.*; -// Ogni filce .java contiene una classe pubblica, con lo stesso nome del file +// 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 @@ -38,59 +39,62 @@ public class LearnJava { // Per stampare a schermo si usa System.out.println System.out.println("Hello World!"); System.out.println( - "Integer: " + 10 + - " Double: " + 3.14 + - " Boolean: " + true); + "Intero [integer]: " + 10 + + " Reale [double]: " + 3.14 + + " Booleano [boolean]: " + true); // Se non si vuole andare a capo, si può usare System.out.print - System.out.print("Hello "); - System.out.print("World"); + System.out.print("Ciao "); + System.out.print("Mondo"); /////////////////////////////////////// // Tipi e Variabili /////////////////////////////////////// // Si dichiara una variabile usando - // Byte - 8-bit signed two's complement integer + // Byte - variabile intera da 8 bit con segno // (-128 <= byte <= 127) byte fooByte = 100; - // Short - 16-bit signed two's complement integer + // Short - variabile intera da 18 bit con segno // (-32,768 <= short <= 32,767) short fooShort = 10000; - // Integer - 32-bit signed two's complement integer + // Integer - variabile intera da 32 bit con segno // (-2,147,483,648 <= int <= 2,147,483,647) int fooInt = 1; - // Long - 64-bit signed two's complement integer + // Long - variabile da 64 bit intera con segno // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) long fooLong = 100000L; - // L is used to denote that this variable value is of type Long; - // anything without is treated as integer by default. + // L viene usato per specificare che il valore dalla variabile + // è di tipo "Long", qualsiasi variabile che non viene contrassegnata + // è trattata di base come un intero. // Nota: Java non dispone di variabili senza segno - // Float - Single-precision 32-bit IEEE 754 Floating Point + // Float - variabile più precisa, con virgola [numeri reali] + // di grandezza 32 bit float fooFloat = 234.5f; - // f is used to denote that this variable value is of type float; - // otherwise it is treated as double. + // f è usato per specificare che la variabile è di tipo "float" + // altrimenti da default viene trattata come "dobule" - // Double - Double-precision 64-bit IEEE 754 Floating Point + // Double - ancora più precisione la si può ottenere con una variabile + // Double, con granzezza di 64 bit. double fooDouble = 123.4; - // Boolean - true & false + // Boolean - vero & falso boolean fooBoolean = true; boolean barBoolean = false; - // Char - A single 16-bit Unicode character + // Char - un singolo carattere con grandezza 16 bit char fooChar = 'A'; // final - Costanti, non possono essere riassegnate ad un altro oggetto final int HOURS_I_WORK_PER_WEEK = 9001; - // Stringhe - String fooString = "My String Is Here!"; + // Stringhe [String] + String fooString = "Ecco una stringa!"; // \n è un carattere speciale che permette di andare a capo. String barString = "Printing on a new line?\nNo Problem!"; @@ -100,7 +104,7 @@ public class LearnJava { System.out.println(barString); System.out.println(bazString); - // Vettori + // Vettori [array] //La lunghezza del vettore deve essere decisa quando viene istanziato //Si può dichiarare come segue: // [] = new []; @@ -111,22 +115,21 @@ public class LearnJava { // Un altro modo per dichiarare & inizializzare un vettore int [] y = {9000, 1000, 1337}; - String names [] = {"Bob", "John", "Fred", "Juan Pedro"}; + String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; boolean bools[] = new boolean[] {true, false, false}; // Accesso diretto ad un elemento System.out.println("intArray @ 0: " + intArray[0]); - // I vettori vengono indicizzati a parire dallo 0, ma sono mutabili + // I vettori vengono indicizzati a parire dallo 0 + // Ma questo indice può essere cambiato. intArray[1] = 1; System.out.println("intArray @ 1: " + intArray[1]); // => 1 - // Altro da aggiungere: - // Liste di array - come i vettori ma vi sono più funzioni - // e la grandezza può variare in corso di esecuzione - // Liste concatenate - // Maps - // HashMaps + // Altro da vedere: + // Liste di array - come i vettori ma più funzionali + // e la loro grandezza può variare in corso di esecuzione + // Liste concatenate di memoria /////////////////////////////////////// // Operatori @@ -153,22 +156,22 @@ public class LearnJava { System.out.println("2 <= 2? " + (2 <= 2)); // => vero System.out.println("2 >= 2? " + (2 >= 2)); // => vero - // Bitwise operators! - // Operatori binari + // Operatori binari orientati ai bit + // effettuano le operazioni logiche confrontando, i bit degli operandi: /* - ~ Unary bitwise complement - << Signed left shift - >> Signed right shift - >>> Unsigned right shift + ~ complemento + << shift sinistro con segno + >> shift destro con segno + >>> shift destro senza segno & AND Binario Bitwise AND ^ OR Esclusivo | OR Incusivo */ - // Incrementare + // Incrementare e Decrementare int i = 0; System.out.println("\n->Incrementare/Decrementare"); - // Gli operatori ++ e -- incrementano e decrementano ripettivamente di 1. + // Gli operatori ++ e -- incrementano e decrementano rispettivamente di 1. // Se posizionati prima della variabile, incrementano, quindi riportano. // Se si trovano dopo la variabile, riporano, e quindi incrementano. System.out.println(i++); //i = 1, Stampa 0 (post-incremento) @@ -308,7 +311,7 @@ public class LearnJava { System.out.println("trek info: " + trek.toString()); } // Fine metodo main -} // Fine classe ImparareJavas +} // Fine classe LearnJava // Si possono inculdere altre anche delle classi non pubbliche (private) @@ -463,7 +466,8 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, In I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici -**Guida ufficiale di Oracle**: + +**Guida ufficiale di Oracle [solo in inglese]**: * [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) @@ -482,19 +486,20 @@ I link di seguito sono solo per capire l'argomento, cerca pure su Google degli e * [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) -**Tutorial Online** + +**Tutorial Online [in inglese]** * [Learneroo.com - Learn Java](http://www.learneroo.com) * [Codingbat.com](http://codingbat.com/java) -**Libri**: +**Libri [in italiano] **: -* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) +* [Java la guida completa](http://www.amazon.it/Java-guida-completa-Herbert-Schildt/dp/8838667667/ref=sr_1_1?ie=UTF8&qid=1393422296&sr=8-1&keywords=java) -* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) +* [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) -* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300) +* [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300) -- cgit v1.2.3 From 06328316d1eee3c578ab66d7d36742c7d3c14887 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Wed, 26 Feb 2014 18:17:19 +0100 Subject: Updated classes name and other -> Middle relase [java/it-it] - Java translation * Completed translation of classes names, variables names ... fixed some errors --- it-it/java.html.markdown | 115 ++++++++++++++++++++++++----------------------- 1 file changed, 58 insertions(+), 57 deletions(-) (limited to 'it-it/java.html.markdown') diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown index afd41af5..702977d3 100644 --- a/it-it/java.html.markdown +++ b/it-it/java.html.markdown @@ -93,7 +93,7 @@ public class LearnJava { // final - Costanti, non possono essere riassegnate ad un altro oggetto final int HOURS_I_WORK_PER_WEEK = 9001; - // Stringhe [String] + // String - Stringhe, array di caratteri (char) String fooString = "Ecco una stringa!"; // \n è un carattere speciale che permette di andare a capo. @@ -300,15 +300,15 @@ public class LearnJava { // (Di seguito la definizione della classe Bicicletta) // Instanziare una nuova classe - Bicycle trek = new Bicycle(); + Bicicletta perocorso = new Bicicletta(); // Chiamare metodi - trek.speedUp(3); // Si usano sempre metodi set... get... - trek.setCadence(100); + perorso.velocità(3); // Si usano sempre metodi set... get... + percorso.setCadenza(100); // toString riporta la rappresenzazione dell'oggetto // come se fosse una stringa - System.out.println("trek info: " + trek.toString()); + System.out.println("percorso info: " + percorso.toString()); } // Fine metodo main } // Fine classe LearnJava @@ -326,136 +326,137 @@ public class LearnJava { class Bicicletta { // Variabili della bicicletta - public int cadence; + public int cadenza; // Public: Può essere richiamato da qualsiasi classe - private int speed; + private int velocità; // Private: è accessibile solo dalla classe dove è stato inizializzato - protected int gear; + protected int ingranaggi; // Protected: è visto sia dalla classe che dalle sottoclassi - String name; + String nome; // default: è accessibile sono all'interno dello stesso package // I costruttori vengono usati per creare variabili // Questo è un costruttore public Bicicletta() { ingranaggi = 1; - ritmo = 50; + cadenza = 50; velocità = 5; nome = "Bontrager"; } // Questo è un costruttore che richiede parametri - public Bicycle(int startCadence, int startSpeed, int startGear, String name) { - this.gear = startGear; - this.cadence = startCadence; - this.speed = startSpeed; - this.name = name; + public Bicicletta(int cadenzaIniziale, int velocitàIniziale, int ingranaggiIniziali, String nome) { + this.ingranaggi = ingranaggiIniziali; + this.cadenza = CadenzaIniziale; + this.velocità = VelocitàIniziale; + this.nome = nome; } // Sintassi delle funzioni: - // () + // () // Le classi in java spesso implementano delle funzioni o metodo // 'get...' o 'set...' // Dichiarazione di un metodo - // () - public int getCadence() { - return cadence; + // () + public int getCandenza() { + return cadenza; } // i medodi (void) non necessitano di riportare un valore - public void setCadence(int newValue) { - cadence = newValue; + public void setCadenza(int nuovoValore) { + cadenza = nuovoValore; } - public void setGear(int newValue) { - gear = newValue; + public void setIngranaggi(int nuovoValore) { + ingranaggi = nuovoValore; } - public void speedUp(int increment) { - speed += increment; + public void accellera(int incrementa) { + velocità += incrementa; } - public void slowDown(int decrement) { - speed -= decrement; + public void decellera(int decrementa) { + velocità -= decrementa; } - public void setName(String newName) { - name = newName; + public void setNome(String nuovoNome) { + nome = nuovoNome; } - public String getName() { - return name; + public String getNome() { + return nome; } //Medoto per visualizzare gli attributi dell'oggetto @Override public String toString() { - return "gear: " + gear + - " cadence: " + cadence + - " speed: " + speed + - " name: " + name; + return "Ingranaggi: " + ingranaggi + + " Cadenza: " + cadenza + + " Velocità: " + velocità + + " Nome: " + nome; } } // Fine classe bicicletta // PennyFarthing è una sottoclasse della bicicletta -class PennyFarthing extends Bicycle { +class PennyFarthing extends Bicicletta { // (Sono quelle biciclette con un unica ruota enorme // Non hanno ingranaggi.) - public PennyFarthing(int startCadence, int startSpeed){ + public PennyFarthing(int cadenzaIniziale, int velocitàIniziale){ // Richiamo il costruttore del padre con super - super(startCadence, startSpeed, 0, "PennyFarthing"); + super(cadenzaIniziale, velocitàIniziale, 0, "PennyFarthing"); } - // You should mark a method you're overriding with an @annotation // Bisogna contrassegnre un medodo che si sta riscrivendo // con una @annotazione // Per saperne di più sulle annotazioni // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ @Override - public void setGear(int gear) { - gear = 0; + public void setIngranaggi(int ingranaggi) { + ingranaggi = 0; } } -//Interfaccie +//Interfacce //Sintassi per dichiarare una interfaccia -// interface extends { -// //Constants -// //Method declarations +// interface extends { +// //Costanti +// //Dichiarazioni dei metodi //} -//Example - Food: -public interface Edible { - public void eat(); //Any class that implements this interface, must implement this method -} +//Esempi- Cibo: +public interface Commestribile { + public void mangia(); + //Ogni classe che implementa questa interfaccia + //deve implementare questo metodo. + } -public interface Digestible { - public void digest(); +public interface Digestibile { + public void digerisci(); } //Possiamo quindi creare una classe che implementa entrambe le interfaccie -public class Fruit implements Edible, Digestible { - public void eat() { +public class Frutta implements Edible, Digestible { + public void mangia() { //... } - public void digest() { + public void digerisci() { //... } } //In Java si può estendere solo una classe, ma si possono implementare //più interfaccie, per esempio: -public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { - public void InterfaceOneMethod() { +public class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia { + public void MetodoPrimaInterfaccia() { } - public void InterfaceTwoMethod() { + public void MetodoSecondaInterfaccia() { } } -- cgit v1.2.3 From 54c3e392379b57786129ef80f816d71416415b35 Mon Sep 17 00:00:00 2001 From: Ivan Sala Date: Thu, 27 Feb 2014 17:05:26 +0100 Subject: Fixed all -> Final relase fixed names, italians sentencens, compile&exec things and so on. now imho this can be merged. --- it-it/java.html.markdown | 124 +++++++++++++++++++++++------------------------ 1 file changed, 61 insertions(+), 63 deletions(-) (limited to 'it-it/java.html.markdown') diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown index 702977d3..b41c7457 100644 --- a/it-it/java.html.markdown +++ b/it-it/java.html.markdown @@ -15,13 +15,13 @@ Java è un linguaggio di programmazione orientato ad oggetti, concorrente, basato su classi e adatto a svariati scopi. [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 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. */ @@ -34,6 +34,8 @@ import java.security.*; 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. public static void main (String[] args) { // Per stampare a schermo si usa System.out.println @@ -43,9 +45,9 @@ public class LearnJava { " Reale [double]: " + 3.14 + " 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("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) long fooLong = 100000L; // L viene usato per specificare che il valore dalla variabile - // è di tipo "Long", qualsiasi variabile che non viene contrassegnata - // è trattata di base come un intero. + // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata + // e' trattata di base come un intero. // 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 float fooFloat = 234.5f; - // f è usato per specificare che la variabile è di tipo "float" - // altrimenti da default viene trattata come "dobule" + // f e' usato per specificare che la variabile e'' di tipo "float" + // 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 fooDouble = 123.4; @@ -93,12 +95,12 @@ public class LearnJava { // final - Costanti, non possono essere riassegnate ad un altro oggetto final int HOURS_I_WORK_PER_WEEK = 9001; - // String - Stringhe, array di caratteri (char) + // String - Stringhe, array di caratteri 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!"; - // \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!"; System.out.println(fooString); System.out.println(barString); @@ -106,7 +108,7 @@ public class LearnJava { // Vettori [array] //La lunghezza del vettore deve essere decisa quando viene istanziato - //Si può dichiarare come segue: + //Si puo' dichiarare come segue: // [] = new []; // [] = new []; int [] intArray = new int[10]; @@ -117,18 +119,17 @@ public class LearnJava { int [] y = {9000, 1000, 1337}; String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; 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]); - // I vettori vengono indicizzati a parire dallo 0 - // Ma questo indice può essere cambiato. + // e' possibile un accesso diretto ad un elemento intArray[1] = 1; System.out.println("intArray @ 1: " + intArray[1]); // => 1 // Altro da vedere: - // Liste di array - come i vettori ma più funzionali - // e la loro grandezza può variare in corso di esecuzione + // Liste di array - come i vettori ma piu' funzionali + // e la loro grandezza puo' variare in corso di esecuzione // Liste concatenate di memoria /////////////////////////////////////// @@ -138,7 +139,7 @@ public class LearnJava { 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("2-1 = " + (i2 - i1)); // => 1 System.out.println("2*1 = " + (i2 * i1)); // => 2 @@ -184,7 +185,7 @@ public class LearnJava { /////////////////////////////////////// System.out.println("\n->Strutture di controllo"); - // La dichiarazione dell'If è C-like. + // La dichiarazione dell'If e'' C-like. int j = 10; if (j == 10){ System.out.println("Io vengo stampato"); @@ -239,7 +240,7 @@ public class LearnJava { // Struttura Switch Case // 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; String stringaMese; switch (mese){ @@ -247,7 +248,7 @@ public class LearnJava { stringaMese = "Genneio"; break; case 2: - strigaMese = "Febbraio"; + stringaMese = "Febbraio"; break; case 3: stringaMese = "Marzo"; @@ -256,16 +257,17 @@ public class LearnJava { stringaMese = "Altri mesi"; break; } - System.out.println("Risultato del costrutto switch:: " + stringaMese); + System.out.println("Risultato del costrutto switch: " + stringaMese); // Condizioni brevi - // Si può usare l'operatore '?' per un rapido assegnamento + // Si puo' usare l'operatore '?' per un rapido assegnamento // o per operazioni logiche. // Si legge: - // Se (condizione) è vera, usa , altrimenti usa + // Se (condizione) e' vera, usa , altrimenti usa int foo = 5; 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) // Instanziare una nuova classe - Bicicletta perocorso = new Bicicletta(); + Bicicletta percorso = new Bicicletta(); // Chiamare metodi - perorso.velocità(3); // Si usano sempre metodi set... get... + percorso.accellera(3); // Si usano sempre metodi set... get... percorso.setCadenza(100); // toString riporta la rappresenzazione dell'oggetto @@ -327,28 +329,28 @@ class Bicicletta { // Variabili della bicicletta public int cadenza; - // Public: Può essere richiamato da qualsiasi classe - private int velocità; - // Private: è accessibile solo dalla classe dove è stato inizializzato + // Public: Puo' essere richiamato da qualsiasi classe + private int velocita; + // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato protected int ingranaggi; - // Protected: è visto sia dalla classe che dalle sottoclassi + // Protected: e'' visto sia dalla classe che dalle sottoclassi 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 - // Questo è un costruttore + // Questo e'' un costruttore public Bicicletta() { ingranaggi = 1; cadenza = 50; - velocità = 5; + velocita = 5; nome = "Bontrager"; } - // Questo è un costruttore che richiede parametri - public Bicicletta(int cadenzaIniziale, int velocitàIniziale, int ingranaggiIniziali, String nome) { - this.ingranaggi = ingranaggiIniziali; - this.cadenza = CadenzaIniziale; - this.velocità = VelocitàIniziale; + // Questo e'' un costruttore che richiede parametri + public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) { + this.ingranaggi = ingranaggi; + this.cadenza = cadenza; + this.velocita = velocita; this.nome = nome; } @@ -374,11 +376,11 @@ class Bicicletta { } public void accellera(int incrementa) { - velocità += incrementa; + velocita += incrementa; } public void decellera(int decrementa) { - velocità -= decrementa; + velocita -= decrementa; } public void setNome(String nuovoNome) { @@ -394,24 +396,24 @@ class Bicicletta { public String toString() { return "Ingranaggi: " + ingranaggi + " Cadenza: " + cadenza + - " Velocità: " + velocità + + " Velocita: " + velocita + " Nome: " + nome; } } // Fine classe bicicletta -// PennyFarthing è una sottoclasse della bicicletta +// PennyFarthing e'' una sottoclasse della bicicletta class PennyFarthing extends Bicicletta { // (Sono quelle biciclette con un unica ruota enorme // Non hanno ingranaggi.) - public PennyFarthing(int cadenzaIniziale, int velocitàIniziale){ + public PennyFarthing(int cadenzaIniziale, int velocitaIniziale){ // 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 // 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/ @Override public void setIngranaggi(int ingranaggi) { @@ -419,27 +421,26 @@ class PennyFarthing extends Bicicletta { } } - +/* //Interfacce //Sintassi per dichiarare una interfaccia // interface extends { -// //Costanti +// //Costanti // //Dichiarazioni dei metodi //} //Esempi- Cibo: -public interface Commestribile { +interface Commestibile { public void mangia(); //Ogni classe che implementa questa interfaccia //deve implementare questo metodo. } - -public interface Digestibile { +interface Digeribile { public void digerisci(); } //Possiamo quindi creare una classe che implementa entrambe le interfaccie -public class Frutta implements Edible, Digestible { +class Frutta implements Commestibile, Digestibile { 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 -//più interfaccie, per esempio: -public class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia { +//In Java si puo' estendere solo una classe, ma si possono implementare +//piu' interfaccie, per esempio: +class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia { public void MetodoPrimaInterfaccia() { } @@ -460,9 +461,8 @@ public class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, Seco } } - +*/ ``` - ## Letture future 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) * [Manuale di Java 7](http://www.amazon.com/gp/product/0071606300) - - -- cgit v1.2.3 From 9c081a7a65a1855253e706e916f4a6a83a7c6d9b Mon Sep 17 00:00:00 2001 From: Ivan Sala Date: Thu, 27 Feb 2014 17:09:27 +0100 Subject: Update java.html.markdown --- it-it/java.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'it-it/java.html.markdown') diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown index b41c7457..4854fc73 100644 --- a/it-it/java.html.markdown +++ b/it-it/java.html.markdown @@ -39,7 +39,7 @@ public class LearnJava { public static void main (String[] args) { // Per stampare a schermo si usa System.out.println - System.out.println("Hello World!"); + System.out.println("Ciao Mondo!"); System.out.println( "Intero [integer]: " + 10 + " Reale [double]: " + 3.14 + @@ -93,15 +93,15 @@ public class LearnJava { char fooChar = 'A'; // final - Costanti, non possono essere riassegnate ad un altro oggetto - final int HOURS_I_WORK_PER_WEEK = 9001; + 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 = "Printing on a new line?\nNo Problem!"; + String barString = "Andare a capo?\nNessun problema!"; // \t e' un carattere speciale che permette di aggiungere un 'Tab' - String bazString = "Do you want to add a tab?\tNo Problem!"; + String bazString = "Vuoi inserire tab?\tNessun problema"; System.out.println(fooString); System.out.println(barString); System.out.println(bazString); @@ -495,7 +495,7 @@ I link di seguito sono solo per capire l'argomento, cerca pure su Google degli e * [Codingbat.com](http://codingbat.com/java) -**Libri [in italiano] **: +**Libri [in italiano]** : * [Java la guida completa](http://www.amazon.it/Java-guida-completa-Herbert-Schildt/dp/8838667667/ref=sr_1_1?ie=UTF8&qid=1393422296&sr=8-1&keywords=java) -- cgit v1.2.3