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') 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') 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') 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') 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') 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 From 12c8e5ca321a5423e93c3ae58dbda12b9a8d3397 Mon Sep 17 00:00:00 2001 From: Ivan Sala Date: Thu, 27 Feb 2014 21:16:30 +0100 Subject: Rename java.html.markdown to java-it.html.markdown --- it-it/java-it.html.markdown | 504 ++++++++++++++++++++++++++++++++++++++++++++ it-it/java.html.markdown | 504 -------------------------------------------- 2 files changed, 504 insertions(+), 504 deletions(-) create mode 100644 it-it/java-it.html.markdown delete mode 100644 it-it/java.html.markdown (limited to 'it-it') diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown new file mode 100644 index 00000000..4854fc73 --- /dev/null +++ b/it-it/java-it.html.markdown @@ -0,0 +1,504 @@ +--- + +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 piu' linee invece sono cosi' +*/ +/** +I commenti per la documentazione JavaDoc si fanno cosi'. +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 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. + public static void main (String[] args) { + + // Per stampare a schermo si usa System.out.println + System.out.println("Ciao Mondo!"); + System.out.println( + "Intero [integer]: " + 10 + + " Reale [double]: " + 3.14 + + " Booleano [boolean]: " + true); + + // Se non si vuole andare a capo, si puo' usare System.out.print + System.out.print("Ciao "); + System.out.print("Mondo "); + + + /////////////////////////////////////// + // Tipi e Variabili + /////////////////////////////////////// + // Si dichiara una variabile usando + // Byte - variabile intera da 8 bit con segno + // (-128 <= byte <= 127) + byte fooByte = 100; + + // Short - variabile intera da 18 bit con segno + // (-32,768 <= short <= 32,767) + short fooShort = 10000; + + // Integer - variabile intera da 32 bit con segno + // (-2,147,483,648 <= int <= 2,147,483,647) + int fooInt = 1; + + // 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 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. + + // Nota: Java non dispone di variabili senza segno + + // Float - variabile piu' precisa, con virgola [numeri reali] + // di grandezza 32 bit + float fooFloat = 234.5f; + // f e' usato per specificare che la variabile e'' di tipo "float" + // altrimenti di default viene trattata come un "dobule" + + // Double - ancora piu' precisione la si puo' ottenere con una variabile + // Double, con granzezza di 64 bit. + double fooDouble = 123.4; + + // Boolean - vero & falso + boolean fooBoolean = true; + boolean barBoolean = false; + + // Char - un singolo carattere con grandezza 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"; + 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: + // [] = 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 nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; + boolean bools[] = new boolean[] {true, false, false}; + + // I vettori vengono indicizzati a parire dallo 0 + System.out.println("intArray @ 0: " + intArray[0]); + + // 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 piu' funzionali + // e la loro grandezza puo' variare in corso di esecuzione + // Liste concatenate di memoria + + /////////////////////////////////////// + // Operatori + /////////////////////////////////////// + System.out.println("\n->Operatori"); + + int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea + + // 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 + 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 + + // Operatori binari orientati ai bit + // effettuano le operazioni logiche confrontando, i bit degli operandi: + /* + ~ complemento + << shift sinistro con segno + >> shift destro con segno + >>> shift destro senza segno + & AND Binario Bitwise AND + ^ OR Esclusivo + | OR Incusivo + */ + + // Incrementare e Decrementare + int i = 0; + System.out.println("\n->Incrementare/Decrementare"); + // 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) + 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 e'' 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 funzionera ovviamente anche con le stringhe. + int mese = 3; + String stringaMese; + switch (mese){ + case 1: + stringaMese = "Genneio"; + break; + case 2: + stringaMese = "Febbraio"; + break; + case 3: + stringaMese = "Marzo"; + break; + default: + stringaMese = "Altri mesi"; + break; + } + System.out.println("Risultato del costrutto switch: " + stringaMese); + + // Condizioni brevi + // Si puo' usare l'operatore '?' per un rapido assegnamento + // o per operazioni logiche. + // Si legge: + // Se (condizione) e' vera, usa , altrimenti usa + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println("Se la condizione e' vera stampa A: "+bar); + // Stampa A, perche' la condizione e' 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 + Bicicletta percorso = new Bicicletta(); + + // Chiamare metodi + percorso.accellera(3); // Si usano sempre metodi set... get... + percorso.setCadenza(100); + + // toString riporta la rappresenzazione dell'oggetto + // come se fosse una stringa + System.out.println("percorso info: " + percorso.toString()); + + } // Fine metodo main +} // Fine classe LearnJava + + +// 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 cadenza; + // Public: Puo' essere richiamato da qualsiasi classe + private int velocita; + // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato + protected int ingranaggi; + // Protected: e'' visto sia dalla classe che dalle sottoclassi + String nome; + // default: e'' accessibile sono all'interno dello stesso package + + // I costruttori vengono usati per creare variabili + // Questo e'' un costruttore + public Bicicletta() { + ingranaggi = 1; + cadenza = 50; + velocita = 5; + nome = "Bontrager"; + } + + // 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; + } + + // Sintassi delle funzioni: + // () + + // Le classi in java spesso implementano delle funzioni o metodo + // 'get...' o 'set...' + + // Dichiarazione di un metodo + // () + public int getCandenza() { + return cadenza; + } + + // i medodi (void) non necessitano di riportare un valore + public void setCadenza(int nuovoValore) { + cadenza = nuovoValore; + } + + public void setIngranaggi(int nuovoValore) { + ingranaggi = nuovoValore; + } + + public void accellera(int incrementa) { + velocita += incrementa; + } + + public void decellera(int decrementa) { + velocita -= decrementa; + } + + public void setNome(String nuovoNome) { + nome = nuovoNome; + } + + public String getNome() { + return nome; + } + + //Medoto per visualizzare gli attributi dell'oggetto + @Override + public String toString() { + return "Ingranaggi: " + ingranaggi + + " Cadenza: " + cadenza + + " Velocita: " + velocita + + " Nome: " + nome; + } +} // Fine classe 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 velocitaIniziale){ + // Richiamo il costruttore del padre con super + super(cadenzaIniziale, velocitaIniziale, 0, "PennyFarthing"); + } + + // Bisogna contrassegnre un medodo che si sta riscrivendo + // con una @annotazione + // Per saperne di piu' sulle annotazioni + // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setIngranaggi(int ingranaggi) { + ingranaggi = 0; + } + +} +/* +//Interfacce +//Sintassi per dichiarare una interfaccia +// interface extends { +// //Costanti +// //Dichiarazioni dei metodi +//} + +//Esempi- Cibo: +interface Commestibile { + public void mangia(); + //Ogni classe che implementa questa interfaccia + //deve implementare questo metodo. + } +interface Digeribile { + public void digerisci(); +} + +//Possiamo quindi creare una classe che implementa entrambe le interfaccie +class Frutta implements Commestibile, Digestibile { + public void mangia() { + //... + } + + public void digerisci() { + //... + } +} + +//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() { + + } + + public void MetodoSecondaInterfaccia() { + + } +} +*/ +``` +## Letture future + +I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici + + +**Guida ufficiale di Oracle [solo in inglese]**: + +* [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 [in inglese]** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**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) + +* [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) diff --git a/it-it/java.html.markdown b/it-it/java.html.markdown deleted file mode 100644 index 4854fc73..00000000 --- a/it-it/java.html.markdown +++ /dev/null @@ -1,504 +0,0 @@ ---- - -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 piu' linee invece sono cosi' -*/ -/** -I commenti per la documentazione JavaDoc si fanno cosi'. -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 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. - public static void main (String[] args) { - - // Per stampare a schermo si usa System.out.println - System.out.println("Ciao Mondo!"); - System.out.println( - "Intero [integer]: " + 10 + - " Reale [double]: " + 3.14 + - " Booleano [boolean]: " + true); - - // Se non si vuole andare a capo, si puo' usare System.out.print - System.out.print("Ciao "); - System.out.print("Mondo "); - - - /////////////////////////////////////// - // Tipi e Variabili - /////////////////////////////////////// - // Si dichiara una variabile usando - // Byte - variabile intera da 8 bit con segno - // (-128 <= byte <= 127) - byte fooByte = 100; - - // Short - variabile intera da 18 bit con segno - // (-32,768 <= short <= 32,767) - short fooShort = 10000; - - // Integer - variabile intera da 32 bit con segno - // (-2,147,483,648 <= int <= 2,147,483,647) - int fooInt = 1; - - // 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 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. - - // Nota: Java non dispone di variabili senza segno - - // Float - variabile piu' precisa, con virgola [numeri reali] - // di grandezza 32 bit - float fooFloat = 234.5f; - // f e' usato per specificare che la variabile e'' di tipo "float" - // altrimenti di default viene trattata come un "dobule" - - // Double - ancora piu' precisione la si puo' ottenere con una variabile - // Double, con granzezza di 64 bit. - double fooDouble = 123.4; - - // Boolean - vero & falso - boolean fooBoolean = true; - boolean barBoolean = false; - - // Char - un singolo carattere con grandezza 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"; - 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: - // [] = 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 nomi [] = {"Andrea", "Bob", "Pippo", "Susan"}; - boolean bools[] = new boolean[] {true, false, false}; - - // I vettori vengono indicizzati a parire dallo 0 - System.out.println("intArray @ 0: " + intArray[0]); - - // 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 piu' funzionali - // e la loro grandezza puo' variare in corso di esecuzione - // Liste concatenate di memoria - - /////////////////////////////////////// - // Operatori - /////////////////////////////////////// - System.out.println("\n->Operatori"); - - int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea - - // 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 - 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 - - // Operatori binari orientati ai bit - // effettuano le operazioni logiche confrontando, i bit degli operandi: - /* - ~ complemento - << shift sinistro con segno - >> shift destro con segno - >>> shift destro senza segno - & AND Binario Bitwise AND - ^ OR Esclusivo - | OR Incusivo - */ - - // Incrementare e Decrementare - int i = 0; - System.out.println("\n->Incrementare/Decrementare"); - // 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) - 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 e'' 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 funzionera ovviamente anche con le stringhe. - int mese = 3; - String stringaMese; - switch (mese){ - case 1: - stringaMese = "Genneio"; - break; - case 2: - stringaMese = "Febbraio"; - break; - case 3: - stringaMese = "Marzo"; - break; - default: - stringaMese = "Altri mesi"; - break; - } - System.out.println("Risultato del costrutto switch: " + stringaMese); - - // Condizioni brevi - // Si puo' usare l'operatore '?' per un rapido assegnamento - // o per operazioni logiche. - // Si legge: - // Se (condizione) e' vera, usa , altrimenti usa - int foo = 5; - String bar = (foo < 10) ? "A" : "B"; - System.out.println("Se la condizione e' vera stampa A: "+bar); - // Stampa A, perche' la condizione e' 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 - Bicicletta percorso = new Bicicletta(); - - // Chiamare metodi - percorso.accellera(3); // Si usano sempre metodi set... get... - percorso.setCadenza(100); - - // toString riporta la rappresenzazione dell'oggetto - // come se fosse una stringa - System.out.println("percorso info: " + percorso.toString()); - - } // Fine metodo main -} // Fine classe LearnJava - - -// 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 cadenza; - // Public: Puo' essere richiamato da qualsiasi classe - private int velocita; - // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato - protected int ingranaggi; - // Protected: e'' visto sia dalla classe che dalle sottoclassi - String nome; - // default: e'' accessibile sono all'interno dello stesso package - - // I costruttori vengono usati per creare variabili - // Questo e'' un costruttore - public Bicicletta() { - ingranaggi = 1; - cadenza = 50; - velocita = 5; - nome = "Bontrager"; - } - - // 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; - } - - // Sintassi delle funzioni: - // () - - // Le classi in java spesso implementano delle funzioni o metodo - // 'get...' o 'set...' - - // Dichiarazione di un metodo - // () - public int getCandenza() { - return cadenza; - } - - // i medodi (void) non necessitano di riportare un valore - public void setCadenza(int nuovoValore) { - cadenza = nuovoValore; - } - - public void setIngranaggi(int nuovoValore) { - ingranaggi = nuovoValore; - } - - public void accellera(int incrementa) { - velocita += incrementa; - } - - public void decellera(int decrementa) { - velocita -= decrementa; - } - - public void setNome(String nuovoNome) { - nome = nuovoNome; - } - - public String getNome() { - return nome; - } - - //Medoto per visualizzare gli attributi dell'oggetto - @Override - public String toString() { - return "Ingranaggi: " + ingranaggi + - " Cadenza: " + cadenza + - " Velocita: " + velocita + - " Nome: " + nome; - } -} // Fine classe 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 velocitaIniziale){ - // Richiamo il costruttore del padre con super - super(cadenzaIniziale, velocitaIniziale, 0, "PennyFarthing"); - } - - // Bisogna contrassegnre un medodo che si sta riscrivendo - // con una @annotazione - // Per saperne di piu' sulle annotazioni - // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/ - @Override - public void setIngranaggi(int ingranaggi) { - ingranaggi = 0; - } - -} -/* -//Interfacce -//Sintassi per dichiarare una interfaccia -// interface extends { -// //Costanti -// //Dichiarazioni dei metodi -//} - -//Esempi- Cibo: -interface Commestibile { - public void mangia(); - //Ogni classe che implementa questa interfaccia - //deve implementare questo metodo. - } -interface Digeribile { - public void digerisci(); -} - -//Possiamo quindi creare una classe che implementa entrambe le interfaccie -class Frutta implements Commestibile, Digestibile { - public void mangia() { - //... - } - - public void digerisci() { - //... - } -} - -//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() { - - } - - public void MetodoSecondaInterfaccia() { - - } -} -*/ -``` -## Letture future - -I link di seguito sono solo per capire l'argomento, cerca pure su Google degli esempi specifici - - -**Guida ufficiale di Oracle [solo in inglese]**: - -* [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 [in inglese]** - -* [Learneroo.com - Learn Java](http://www.learneroo.com) - -* [Codingbat.com](http://codingbat.com/java) - - -**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) - -* [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 25d54beab143de977627bbcf0821782551788bf1 Mon Sep 17 00:00:00 2001 From: Ivan Sala Date: Thu, 27 Feb 2014 21:18:58 +0100 Subject: Update java-it.html.markdown --- it-it/java-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown index 4854fc73..127569c3 100644 --- a/it-it/java-it.html.markdown +++ b/it-it/java-it.html.markdown @@ -1,7 +1,7 @@ --- language: java -filename: LearnJava.java +filename: LearnJava-it.java contributors: - ["Jake Prather", "http://github.com/JakeHP"] - ["Madison Dickson", "http://github.com/mix3d"] -- cgit v1.2.3 From d8fd766c8803b5c19eaea832e41ef2c333268a71 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Thu, 27 Feb 2014 14:19:42 -0800 Subject: Update java-it.html.markdown --- it-it/java-it.html.markdown | 2 -- 1 file changed, 2 deletions(-) (limited to 'it-it') diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown index 127569c3..91eb0162 100644 --- a/it-it/java-it.html.markdown +++ b/it-it/java-it.html.markdown @@ -1,5 +1,4 @@ --- - language: java filename: LearnJava-it.java contributors: @@ -8,7 +7,6 @@ contributors: translators: - ["Ivan Sala","http://github.com/dev-sala"] lang: it-it - --- Java è un linguaggio di programmazione orientato ad oggetti, -- cgit v1.2.3 From 31b542777449d6a2a8bbd66a0e1cf570ea82e335 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Thu, 27 Feb 2014 22:26:49 +0000 Subject: Oops, syntax highlighter didn't like that. --- it-it/java-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown index 91eb0162..fb91aa19 100644 --- a/it-it/java-it.html.markdown +++ b/it-it/java-it.html.markdown @@ -13,7 +13,7 @@ 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 piu' linee invece sono cosi' -- cgit v1.2.3 From d756acce79a8fbac549251dae329650f99ba5533 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Wed, 5 Mar 2014 16:06:23 +0100 Subject: [Brainfuck/it-it] started the translation\n\nStarted the english-italian translation of Brainfuck document. --- it-it/.java-it.html.markdown.swp | Bin 0 -> 16384 bytes it-it/brainfuck-it.html.markdown | 92 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) create mode 100644 it-it/.java-it.html.markdown.swp create mode 100644 it-it/brainfuck-it.html.markdown (limited to 'it-it') diff --git a/it-it/.java-it.html.markdown.swp b/it-it/.java-it.html.markdown.swp new file mode 100644 index 00000000..6a112d73 Binary files /dev/null and b/it-it/.java-it.html.markdown.swp differ diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown new file mode 100644 index 00000000..9b882b2f --- /dev/null +++ b/it-it/brainfuck-it.html.markdown @@ -0,0 +1,92 @@ +--- + +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Ivan Sala", "http://slavni.github.io/"] +lang: it-it + +--- + +Brainfuck è un linguaggio di programmazione estremamente minimale, +ma è ingrado di rappresentare completamente una macchina di turnig, +e sfrutta solo 8 caratteri. +[Per saperne di più](http://it.wikipedia.org/wiki/Brainfuck) + +``` + +Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) viene ignorato. +Branfuck è caratterizzato da un array (vettore) di 30,000 celle inizializzare a zero, e un puntatore che punta alla cella corrente. + +Vi sono solo otto comando: ++ : Incrementa il valore della cella attuale di uno. +- : Decrementa il valore della cella attuale di uno. +> : Sposta il puntatore sulla cella seguente (prossima a destra). +< : Sposta il puntatore sulla cella precendete (precedente a sinistra). +. : Stampa il valore in ASCII della cella corrente. (es: 65 = 'A') +, : Legge un singolo carattere come input per la cella corrente. +[ : Se il valore della cella corrente è zero, conclude il ciclo + andando alla sua corrispondente ]. + Altrimenti, passa alla prossima istruzione. +] : Se il valore della cella corrente è zero, passa alla prossima istruzione. + Altrimenti torna indetro fino alla [ corrispondente. + +[ e ] creano un loop (while). Ovviamente dovranno essere bilanciati. +Per ogni [ dovrà corrispondere una ] + +Alcuni semplici esempi di programmi scritti in Brainfuck: + +++++++ [ > ++++++++++ < - ] > +++++ . + +Questo programma stampa in output la lettera 'A'. Priam incrementa +la cella #1 fino a 6, Quindi la cella #1 viene usata per crare un ciclo. +Poi, entra in un loop ([) e si sposta alla cella #2. +Incrementa la cella #2 10 volte, e torna alla cella #1, e la decrementa. +Questo avviene 6 volte (servono che la cella #1 venga decrementata 6 volte +per raggiungere lo 0. Quindi passa alla corrispondente ] e prosegue). + +A questo punto, siamo sulla cella #1, che ha valore 0, +la cella #2 ha valore 60 (6*10). Ci spostiamo sulla cella #2, incrementiamo +per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella +#2 (.). +65 è 'A' in ASCII, quindi alla fine viene stampata 'A'. + + +, [ > + < - ] > . + +This program reads a character from the user input and copies the character into +cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2, +move back to cell #1, and decrement the value at cell #1. This continues on +until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on +cell #1 at the end of the loop, move to cell #2, and then print out the value +in ASCII. + +Also keep in mind that the spaces are purely for readability purposes. You +could just as easily write it as: + +,[>+<-]>. + +Try and figure out what this program does: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +This program takes two numbers for input, and multiplies them. + +The gist is it first reads in two inputs. Then it starts the outer loop, +conditioned on cell #1. Then it moves to cell #2, and starts the inner +loop conditioned on cell #2, incrementing cell #3. However, there comes a +problem: At the end of the inner loop, cell #2 is zero. In that case, +inner loop won't work anymore since next time. To solve this problem, +we also increment cell #4, and then recopy cell #4 into cell #2. +Then cell #3 is the result. +``` + +E questo è brainfuck...Non è difficele, vero? +Per divertimento adesso puoi scrivere i tuoi programmi in brainfuck, +oppure puoi scrivere un interprete brainfuck in un altro linguaggio. +L'interprete è abbastanza semplice da implementare, ma se sei veramente +masochista prova ad implementare un interprete brainfuck in... +brainfuck. + -- cgit v1.2.3 From 07e8f770d9a875afc01fa9c31fb406f4c5e1f3fd Mon Sep 17 00:00:00 2001 From: dev-sala Date: Wed, 5 Mar 2014 16:06:34 +0100 Subject: [Brainfuck/it-it] started the translation\n\nStarted the english-italian translation of Brainfuck document. --- it-it/.java-it.html.markdown.swp | Bin 16384 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 it-it/.java-it.html.markdown.swp (limited to 'it-it') diff --git a/it-it/.java-it.html.markdown.swp b/it-it/.java-it.html.markdown.swp deleted file mode 100644 index 6a112d73..00000000 Binary files a/it-it/.java-it.html.markdown.swp and /dev/null differ -- cgit v1.2.3 From 0bea9954748c01f5e039ec940630ff3447148655 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Wed, 5 Mar 2014 16:12:13 +0100 Subject: [Brainfuck/it-it] some fixes\n\nWrong translator name. Italian corrections --- it-it/brainfuck-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown index 9b882b2f..2705fb4c 100644 --- a/it-it/brainfuck-it.html.markdown +++ b/it-it/brainfuck-it.html.markdown @@ -5,7 +5,7 @@ contributors: - ["Prajit Ramachandran", "http://prajitr.github.io/"] - ["Mathias Bynens", "http://mathiasbynens.be/"] translators: - - ["Ivan Sala", "http://slavni.github.io/"] + - ["Ivan Sala", "http://slavni96.github.io/"] lang: it-it --- -- cgit v1.2.3 From 64e6da392320d0706520f4edf9008f8a775c8a78 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Tue, 11 Mar 2014 15:37:10 +0100 Subject: Complited translation finishied translating brainfuck form english to italian --- it-it/brainfuck-it.html.markdown | 50 ++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 20 deletions(-) (limited to 'it-it') diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown index 2705fb4c..9316c35e 100644 --- a/it-it/brainfuck-it.html.markdown +++ b/it-it/brainfuck-it.html.markdown @@ -17,8 +17,10 @@ e sfrutta solo 8 caratteri. ``` -Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) viene ignorato. -Branfuck è caratterizzato da un array (vettore) di 30,000 celle inizializzare a zero, e un puntatore che punta alla cella corrente. +Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) +viene ignorato. +Branfuck è caratterizzato da un array (vettore) di 30,000 celle +inizializzare a zero, e un puntatore che punta alla cella corrente. Vi sono solo otto comando: + : Incrementa il valore della cella attuale di uno. @@ -56,31 +58,39 @@ per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella , [ > + < - ] > . -This program reads a character from the user input and copies the character into -cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2, -move back to cell #1, and decrement the value at cell #1. This continues on -until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on -cell #1 at the end of the loop, move to cell #2, and then print out the value -in ASCII. +Questo programma legge un carattere come input dall'utente, +quindi salva il carattere dentro la cella #1. +In seguito, incominca a ciclare. +Si sposta alla cella #², e increementa il valore della cella (#2). +Quindi torna alla cella #1, e decrementa il valore della cella (#1). +Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2 +avrà il valore iniziale della cella #1. +Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta +sulla cella #2 e stampa il valore in ASCII. -Also keep in mind that the spaces are purely for readability purposes. You -could just as easily write it as: +Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere +una maggiore leggibilità, si poteva anche scrivere senza: ,[>+<-]>. -Try and figure out what this program does: +Proviamo, adesso, a capire cosa fa invece questo programma: ,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> -This program takes two numbers for input, and multiplies them. - -The gist is it first reads in two inputs. Then it starts the outer loop, -conditioned on cell #1. Then it moves to cell #2, and starts the inner -loop conditioned on cell #2, incrementing cell #3. However, there comes a -problem: At the end of the inner loop, cell #2 is zero. In that case, -inner loop won't work anymore since next time. To solve this problem, -we also increment cell #4, and then recopy cell #4 into cell #2. -Then cell #3 is the result. +Prende due numeri in input e quindi li moltiplica. + +Prima prende in input i due numeri (,>,<), quindi inizia un cilclo +basandosi sulla cella #1. +Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato +dal valore della cella #2, incrementando la cella #3. +Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno +la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà +partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0. +Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella +#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 +nella cella #2, in modo che il ciclo interno +possa essere eseguito una altra volta. +Alla fine la cella #3 contiene il risultato. ``` E questo è brainfuck...Non è difficele, vero? -- cgit v1.2.3 From 92aa655d76f05ead8b4c9130f575740c1233e8ab Mon Sep 17 00:00:00 2001 From: dev-sala Date: Tue, 11 Mar 2014 15:40:05 +0100 Subject: Revert "Complited translation" This reverts commit 64e6da392320d0706520f4edf9008f8a775c8a78. --- it-it/brainfuck-it.html.markdown | 50 ++++++++++++++++------------------------ 1 file changed, 20 insertions(+), 30 deletions(-) (limited to 'it-it') diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown index 9316c35e..2705fb4c 100644 --- a/it-it/brainfuck-it.html.markdown +++ b/it-it/brainfuck-it.html.markdown @@ -17,10 +17,8 @@ e sfrutta solo 8 caratteri. ``` -Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) -viene ignorato. -Branfuck è caratterizzato da un array (vettore) di 30,000 celle -inizializzare a zero, e un puntatore che punta alla cella corrente. +Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) viene ignorato. +Branfuck è caratterizzato da un array (vettore) di 30,000 celle inizializzare a zero, e un puntatore che punta alla cella corrente. Vi sono solo otto comando: + : Incrementa il valore della cella attuale di uno. @@ -58,39 +56,31 @@ per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella , [ > + < - ] > . -Questo programma legge un carattere come input dall'utente, -quindi salva il carattere dentro la cella #1. -In seguito, incominca a ciclare. -Si sposta alla cella #², e increementa il valore della cella (#2). -Quindi torna alla cella #1, e decrementa il valore della cella (#1). -Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2 -avrà il valore iniziale della cella #1. -Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta -sulla cella #2 e stampa il valore in ASCII. +This program reads a character from the user input and copies the character into +cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2, +move back to cell #1, and decrement the value at cell #1. This continues on +until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on +cell #1 at the end of the loop, move to cell #2, and then print out the value +in ASCII. -Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere -una maggiore leggibilità, si poteva anche scrivere senza: +Also keep in mind that the spaces are purely for readability purposes. You +could just as easily write it as: ,[>+<-]>. -Proviamo, adesso, a capire cosa fa invece questo programma: +Try and figure out what this program does: ,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> -Prende due numeri in input e quindi li moltiplica. - -Prima prende in input i due numeri (,>,<), quindi inizia un cilclo -basandosi sulla cella #1. -Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato -dal valore della cella #2, incrementando la cella #3. -Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno -la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà -partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0. -Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella -#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 -nella cella #2, in modo che il ciclo interno -possa essere eseguito una altra volta. -Alla fine la cella #3 contiene il risultato. +This program takes two numbers for input, and multiplies them. + +The gist is it first reads in two inputs. Then it starts the outer loop, +conditioned on cell #1. Then it moves to cell #2, and starts the inner +loop conditioned on cell #2, incrementing cell #3. However, there comes a +problem: At the end of the inner loop, cell #2 is zero. In that case, +inner loop won't work anymore since next time. To solve this problem, +we also increment cell #4, and then recopy cell #4 into cell #2. +Then cell #3 is the result. ``` E questo è brainfuck...Non è difficele, vero? -- cgit v1.2.3 From a679cc8281627bfce9337774fb076bcd402007e5 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Tue, 11 Mar 2014 15:44:47 +0100 Subject: Complited translation finished translating brainfuck from english to italian --- it-it/brainfuck-it.html.markdown | 51 +++++++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 21 deletions(-) (limited to 'it-it') diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown index 2705fb4c..4999d7e6 100644 --- a/it-it/brainfuck-it.html.markdown +++ b/it-it/brainfuck-it.html.markdown @@ -17,8 +17,10 @@ e sfrutta solo 8 caratteri. ``` -Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) viene ignorato. -Branfuck è caratterizzato da un array (vettore) di 30,000 celle inizializzare a zero, e un puntatore che punta alla cella corrente. +Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) +viene ignorato. +Branfuck è caratterizzato da un array (vettore) di 30,000 celle +inizializzare a zero, e un puntatore che punta alla cella corrente. Vi sono solo otto comando: + : Incrementa il valore della cella attuale di uno. @@ -56,31 +58,39 @@ per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella , [ > + < - ] > . -This program reads a character from the user input and copies the character into -cell #1. Then we start a loop. Move to cell #2, increment the value at cell #2, -move back to cell #1, and decrement the value at cell #1. This continues on -until cell #1 is 0, and cell #2 holds cell #1's old value. Because we're on -cell #1 at the end of the loop, move to cell #2, and then print out the value -in ASCII. +Questo programma legge un carattere come input dall'utente, +quindi salva il carattere dentro la cella #1. +In seguito, incominca a ciclare. +Si sposta alla cella #², e increementa il valore della cella (#2). +Quindi torna alla cella #1, e decrementa il valore della cella (#1). +Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2 +avrà il valore iniziale della cella #1. +Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta +sulla cella #2 e stampa il valore in ASCII. -Also keep in mind that the spaces are purely for readability purposes. You -could just as easily write it as: +Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere +una maggiore leggibilità, si poteva anche scrivere senza: ,[>+<-]>. -Try and figure out what this program does: +Proviamo, adesso, a capire cosa fa invece questo programma: ,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> -This program takes two numbers for input, and multiplies them. - -The gist is it first reads in two inputs. Then it starts the outer loop, -conditioned on cell #1. Then it moves to cell #2, and starts the inner -loop conditioned on cell #2, incrementing cell #3. However, there comes a -problem: At the end of the inner loop, cell #2 is zero. In that case, -inner loop won't work anymore since next time. To solve this problem, -we also increment cell #4, and then recopy cell #4 into cell #2. -Then cell #3 is the result. +Prende due numeri in input e quindi li moltiplica. + +Prima prende in input i due numeri (,>,<), quindi inizia un cilclo +basandosi sulla cella #1. +Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato +dal valore della cella #2, incrementando la cella #3. +Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno +la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà +partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0. +Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella +#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 +nella cella #2, in modo che il ciclo interno +possa essere eseguito una altra volta. +Alla fine la cella #3 contiene il risultato. ``` E questo è brainfuck...Non è difficele, vero? @@ -89,4 +99,3 @@ oppure puoi scrivere un interprete brainfuck in un altro linguaggio. L'interprete è abbastanza semplice da implementare, ma se sei veramente masochista prova ad implementare un interprete brainfuck in... brainfuck. - -- cgit v1.2.3 From 194d910e1bfc897592e2431cc06bd78865afc933 Mon Sep 17 00:00:00 2001 From: dev-sala Date: Tue, 11 Mar 2014 15:50:12 +0100 Subject: [Java/it-it] fixed link --- it-it/java-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown index 127569c3..e729f223 100644 --- a/it-it/java-it.html.markdown +++ b/it-it/java-it.html.markdown @@ -6,7 +6,7 @@ contributors: - ["Jake Prather", "http://github.com/JakeHP"] - ["Madison Dickson", "http://github.com/mix3d"] translators: - - ["Ivan Sala","http://github.com/dev-sala"] + - ["Ivan Sala","http://github.com/slavni96"] lang: it-it --- -- cgit v1.2.3 From f3ba1c8a19ae42d296b5b10d50f6254ce2736c23 Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Fri, 24 Apr 2015 22:45:14 -0700 Subject: added italian JSON translation --- it-it/json-it.html.markdown | 62 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 it-it/json-it.html.markdown (limited to 'it-it') diff --git a/it-it/json-it.html.markdown b/it-it/json-it.html.markdown new file mode 100644 index 00000000..0c401753 --- /dev/null +++ b/it-it/json-it.html.markdown @@ -0,0 +1,62 @@ +--- + +language: json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it + +--- + +Dato che JSON è un formato per lo scambio di dati estremamente semplice, questo sarà con molta probabilità +il più semplice Learn X in Y Minutes. + +Nella sua forma più pura JSON non ha commenti, ma molti parser accettano +commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sarà +100% JSON valido. Fortunatamente, si spiega da sè. + +```json +{ + "chiave": "valore", + + "chiavi": "devono sempre essere racchiuse tra doppi apici", + "numeri": 0, + "stringhe": "Ciaø, møndø. Tutti gli unicode sono permessi, assieme con l \"escaping\".", + "ha booleani?": true, + "il nulla": null, + + "numero grande": 1.2e+100, + + "oggetti": { + "commento": "La maggior parte della tua struttura viene dagli oggetti.", + + "array": [0, 1, 2, 3, "Gli array possono contenere qualsiasi cosa.", 5], + + "un altro oggetto": { + "commento": "Queste cose possono essere annidate, molto utile." + } + }, + + "sciocchezze": [ + { + "sorgenti di potassio": ["banane"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "stile alternativo": { + "commento": "Guarda quà!" + , "posizione della virgola": "non conta - fintantochè è prima del valore, allora è valida" + , "un altro commento": "che bello" + }, + + "è stato molto breve": "Ed hai finito. Adesso sai tutto cio che JSON ha da offrire." +} +``` -- cgit v1.2.3 From 3a9138beafc9f0ca0b007ac7c27f664f6c7c42af Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Sat, 2 May 2015 17:00:56 -0700 Subject: added italian translation of bash --- it-it/bash-it.html.markdown | 275 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 it-it/bash-it.html.markdown (limited to 'it-it') diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown new file mode 100644 index 00000000..a4391258 --- /dev/null +++ b/it-it/bash-it.html.markdown @@ -0,0 +1,275 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] +filename: LearnBash.sh +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it +--- + +Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X. +Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell. + +[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# La prima riga dello script è lo shebang il quale dice al sistema come eseguire +# lo script: http://it.wikipedia.org/wiki/Shabang +# Come avrai già immaginato, i commenti iniziano con #. Lo shebang stesso è un commento. + +# Semplice esempio ciao mondo: +echo Ciao mondo! + +# Ogni comando inizia su una nuova riga, o dopo un punto e virgola: +echo 'Questa è la prima riga'; echo 'Questa è la seconda riga' + +# Per dichiarare una variabile: +VARIABILE="Una stringa" + +# Ma non così: +VARIABILE = "Una stringa" +# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore +# perchè non esiste. + +# Usare la variabile: +echo $VARIABILE +echo "$VARIABILE" +echo '$VARIABILE' +# Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi +# il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $. +# Nota che ' (singolo apice) non espande le variabili! + +# Sostituzione di stringhe nelle variabili +echo ${VARIABILE/Una/A} +# Questo sostituirà la prima occorrenza di "Una" con "La" + +# Sottostringa di una variabile +echo ${VARIABILE:0:7} +# Questo ritornera solamente i primi 7 caratteri + +# Valore di default per la variabile +echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"} +# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0 + +# Variabili builtin: +# Ci sono delle variabili builtin molto utili, come +echo "Valore di ritorno dell'ultimo programma eseguito: $?" +echo "PID dello script: $$" +echo "Numero di argomenti: $#" +echo "Argomenti dello script: $@" +echo "Argomenti dello script separati in variabili distinte: $1 $2..." + +# Leggere un valore di input: +echo "Come ti chiami?" +read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile +echo Ciao, $NOME! + +# Classica struttura if: +# usa 'man test' per maggiori informazioni sulle condizionali +if [ $NOME -ne $USER ] +then + echo "Il tuo nome non è lo username" +else + echo "Il tuo nome è lo username" +fi + +# C'è anche l'esecuzione condizionale +echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce" +echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce" + +# Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre: +if [ $NOME == "Steve" ] && [ $ETA -eq 15 ] +then + echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15." +fi + +if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ] +then + echo "Questo verrà eseguito se $NAME è Daniya O Zach." +fi + +# Le espressioni sono nel seguente formato: +echo $(( 10 + 5 )) + +# A differenza di altri linguaggi di programmazione, bash è una shell - quindi lavora nel contesto +# della cartella corrente. Puoi elencare i file e le cartelle nella cartella +# corrente con il comando ls: +ls + +# Questi comandi hanno opzioni che controllano la loro esecuzione: +ls -l # Elenca tutti i file e le cartelle su una riga separata + +# I risultati del comando precedente possono essere passati al comando successivo come input. +# Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i +# file .txt nella cartella corrente: +ls -l | grep "\.txt" + +# Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr). +# Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe +# comprese tra "EOF": +cat > hello.py << EOF +#!/usr/bin/env python +from __future__ import print_function +import sys +print("#stdout", file=sys.stdout) +print("#stderr", file=sys.stderr) +for line in sys.stdin: + print(line, file=sys.stdout) +EOF + +# Esegui hello.py con diverse redirezioni stdin, stdout, e stderr: +python hello.py < "input.in" +python hello.py > "output.out" +python hello.py 2> "error.err" +python hello.py > "output-and-error.log" 2>&1 +python hello.py > /dev/null 2>&1 +# Lo output error sovrascriverà il file se esiste, +# se invece vuoi appendere usa ">>": +python hello.py >> "output.out" 2>> "error.err" + +# Sovrascrivi output.txt, appendi a error.err, e conta le righe: +info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err +wc -l output.out error.err + +# Esegui un comando e stampa il suo file descriptor (esempio: /dev/fd/123) +# vedi: man fd +echo <(echo "#ciaomondo") + +# Sovrascrivi output.txt con "#helloworld": +cat > output.out <(echo "#helloworld") +echo "#helloworld" > output.out +echo "#helloworld" | cat > output.out +echo "#helloworld" | tee output.out >/dev/null + +# Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva) +rm -v output.out error.err output-and-error.log + +# I comandi possono essere sostituiti con altri comandi usando $( ): +# Il comando seguente mostra il numero di file e cartelle nella +# cartella corrente. +echo "Ci sono $(ls | wc -l) oggetti qui." + +# Lo stesso puo' essere usato usando backticks `` ma non possono essere innestati - il modo migliore +# è usando $( ). +echo "Ci sono `ls | wc -l` oggetti qui." + +# Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++: +case "$VARIABILE" in + #Lista di pattern per le condizioni che vuoi soddisfare + 0) echo "C'è uno zero.";; + 1) echo "C'è un uno.";; + *) echo "Non è null.";; +esac + +# I cicli for iterano per ogni argomento fornito: +# I contenuti di $VARIABILE sono stampati tre volte. +for VARIABILE in {1..3} +do + echo "$VARIABILE" +done + +# O scrivilo con il "ciclo for tradizionale": +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Possono essere usati anche per agire su file.. +# Questo eseguirà il comando 'cat' su file1 e file2 +for VARIABILE in file1 file2 +do + cat "$VARIABILE" +done + +# ..o dall'output di un comando +# Questo eseguirà cat sull'output di ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# while loop: +while [ true ] +do + echo "corpo del loop..." + break +done + +# Puoi anche definire funzioni +# Definizione: +function foo () +{ + echo "Gli argomenti funzionano come gli argomenti dello script: $@" + echo "E: $1 $2..." + echo "Questa è una funzione" + return 0 +} + +# o semplicemente +bar () +{ + echo "Un altro modo per dichiarare funzioni!" + return 0 +} + +# Per chiamare la funzione +foo "Il mio nome è" $NOME + +# Ci sono un sacco di comandi utili che dovresti imparare: +# stampa le ultime 10 righe di file.txt +tail -n 10 file.txt +# stampa le prime 10 righe di file.txt +head -n 10 file.txt +# ordina le righe di file.txt +sort file.txt +# riporta o ometti le righe ripetute, con -d le riporta +uniq -d file.txt +# stampa solamente la prima colonna prima del carattere ',' +cut -d ',' -f 1 file.txt +# sostituisce ogni occorrenza di 'okay' con 'great' in file.txt (compatible con le regex) +sed -i 's/okay/great/g' file.txt +# stampa su stdout tutte le righe di file.txt che soddisfano una certa regex +# L'esempio stampa le righe che iniziano con "foo" e che finiscono con "bar" +grep "^foo.*bar$" file.txt +# passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex +grep -c "^foo.*bar$" file.txt +# se vuoi letteralmente cercare la stringa, +# e non la regex, usa fgrep (o grep -F) +fgrep "^foo.*bar$" file.txt + + +# Leggi la documentazione dei builtin di bash con il builtin 'help' di bash: +help +help help +help for +help return +help source +help . + +# Leggi la manpage di bash con man +apropos bash +man 1 bash +man bash + +# Leggi la documentazione con info (? per help) +apropos info | grep '^info.*(' +man info +info info +info 5 info + +# Leggi la documentazione di bash: +info bash +info bash 'Bash Features' +info bash 6 +info --apropos bash +``` -- cgit v1.2.3 From df788639e6e4ee824ecf817e28e8dcaac48b5504 Mon Sep 17 00:00:00 2001 From: sinkswim Date: Sat, 2 May 2015 17:24:45 -0700 Subject: Update bash-it.html.markdown --- it-it/bash-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown index a4391258..f892845f 100644 --- a/it-it/bash-it.html.markdown +++ b/it-it/bash-it.html.markdown @@ -55,7 +55,7 @@ echo ${VARIABILE/Una/A} # Sottostringa di una variabile echo ${VARIABILE:0:7} -# Questo ritornera solamente i primi 7 caratteri +# Questo ritornerà solamente i primi 7 caratteri # Valore di default per la variabile echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"} -- cgit v1.2.3 From 4e28ec0efdc127b51930aaa8de4f92e08c66011f Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Tue, 5 May 2015 21:21:53 -0700 Subject: new C++ it version --- it-it/c++-it.html.markdown | 597 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 597 insertions(+) create mode 100644 it-it/c++-it.html.markdown (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown new file mode 100644 index 00000000..8914c234 --- /dev/null +++ b/it-it/c++-it.html.markdown @@ -0,0 +1,597 @@ +--- +language: c++ +filename: learncpp.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] +translators: + - ["Robert Margelli", "http://github.com/sinkswim/"] +lang: it-it +--- + +Il C++ e' un linguaggio di programmazione il quale, +[secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +e' stato progettato per + +- essere un "miglior C" +- supportare l'astrazione dei dati +- supportare la programmazione orientata agli oggetti +- supportare la programmazione generica + +Nonostante la sintassi possa risultare piu' difficile o complessa di linguaggi piu' recenti, +e' usato in maniera vasta poiche' viene compilato in istruzioni macchina che possono +essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C) +ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi. +Questa combinazione di velocita' e funzionalita' rende il C++ +uno dei piu' utilizzati linguaggi di programmazione. + +```c++ +////////////////// +// Confronto con il C +////////////////// + +// Il C++ e' _quasi_ un superset del C e con esso condivide la sintassi di base per +// la dichiarazione di variabili, tipi primitivi, e funzioni. + +// Proprio come nel C, l'inizio del programma e' una funzione chiamata +// main con un intero come tipo di ritorno, +// nonostante void main() sia anch'essa accettata dalla maggior parte dei compilatori(gcc, clang, ecc...) +// Questo valore serve come stato d'uscita del programma. +// Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni. +int main(int argc, char** argv) +{ + // Gli argomenti a linea di comando sono passati tramite argc e argv cosi' come + // avviene in C. + // argc indica il numero di argomenti, + // e argv e' un array in stile-C di stringhe (char*) + // che rappresenta gl iargomenti. + // Il primo argomento e' il nome che e' stato assegnato al programma. + // argc e argv possono essere omessi se non hai bisogno di argomenti, + // in questa maniera la funzione avra' int main() come firma. + + // Lo stato di uscita 0 indica successo. + return 0; +} + +// Tuttavia, il C++ varia nei seguenti modi: + +// In C++, i caratteri come letterali sono da un byte. +sizeof('c') == 1 + +// In C, i caratteri come letterali sono della stessa dimensione degli interi. +sizeof('c') == sizeof(10) + + +// C++ ha prototipizzazione rigida +void func(); // funziona che non accetta argomenti + +// In C +void func(); // funzione che puo' accettare un qualsiasi numero di argomenti + +// Usa nullptr invece di NULL in C++ +int* ip = nullptr; + +// Gli header C standard sono disponibili in C++, +// ma sono prefissati con "c" e non hanno il suffisso ".h". +#include + +int main() +{ + printf("Ciao, mondo!\n"); + return 0; +} + +/////////////////////////////// +// Overloading per le funzioni +////////////////////////////// + +// Il C++ supporta l'overloading per le funzioni +// sia dato che ogni funzione accetta parametri diversi. + +void print(char const* myString) +{ + printf("Stringa %s\n", myString); +} + +void print(int myInt) +{ + printf("Il mio int e' %d", myInt); +} + +int main() +{ + print("Ciao"); // Viene chiamata void print(const char*) + print(15); // Viene chiamata void print(int) +} + +//////////////////////// +// Argomenti di default +/////////////////////// + +// Puoi fornire argomenti di default per una funzione +// se non sono forniti dal chiamante. + +void faiQualcosaConInteri(int a = 1, int b = 4) +{ + // fai qualcosa con gli interi qui +} + +int main() +{ + faiQualcosaConInteri(); // a = 1, b = 4 + faiQualcosaConInteri(20); // a = 20, b = 4 + faiQualcosaConInteri(20, 5); // a = 20, b = 5 +} + +// Gli argomenti di default devono essere alla fine della lista degli argomenti. + +void dichiarazioneInvalida(int a = 1, int b) // Errore! +{ +} + + +///////////// +// Namespaces +///////////// + +// I namespaces forniscono visibilita' separata per dichiarazioni di variabili, funzioni, +// ed altro. +// I namespaces possono essere annidati. + +namespace Primo { + namespace Annidato { + void foo() + { + printf("Questa e' Primo::Annidato::foo\n"); + } + } // fine di namespace Annidato +} // fine di namespace Primo + +namespace Secondo { + void foo() + { + printf("Questa e' Secondo::foo\n") + } +} + +void foo() +{ + printf("Questa e' foo globale\n"); +} + +int main() +{ + // Assume che tutto venga dal namespace "Secondo" + // a meno che non venga dichiarato altrimenti. + using namespace Secondo; + + foo(); // stampa "Questa e' Secondo::foo" + Primo::Annidato::foo(); // stampa "Questa e' Primo::Annidato::foo" + ::foo(); // stampa "Questa e' foo globale" +} + +/////////////// +// Input/Output +/////////////// + +// L'input e l'output in C++ utilizza gli streams +// cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr. +// << e' l'operatore di inserzione >> e' l'operatore di estrazione. + +#include // Include for I/O streams + +using namespace std; // Gli streams sono nel namespace std (libreria standard) + +int main() +{ + int myInt; + + // Stampa su stdout (o terminalee/schermo) + cout << "Inserisci il tuo numero preferito:\n"; + // Prende l'input + cin >> myInt; + + // cout puo' anche essere formattato + cout << "Il tuo numero preferito e' " << myInt << "\n"; + // stampa "Il tuo numero preferito e' " + + cerr << "Usato per messaggi di errore"; +} + +//////////// +// Stringhe +/////////// + +// Le stringhe in C++ sono oggetti ed hanno molte funzioni membro +#include + +using namespace std; // Anche le stringhe sono contenute nel namespace std (libreria standard) + +string myString = "Ciao"; +string myOtherString = " Mondo"; + +// + e' usato per la concatenazione. +cout << myString + myOtherString; // "Ciao Mondo" + +cout << myString + " Bella"; // "Ciao Bella" + +// le stringhe in C++ possono essere modificate. +myString.append(" Mario"); +cout << myString; // "Ciao Mario" + + +/////////////// +// Riferimenti +////////////// + +// Oltre ai puntatori come quelli in C, +// il C++ ha i _riferimenti_. +// Questi non sono tipi puntatori che non possono essere riassegnati una volta settati +// e non possono essere null. +// Inoltre, essi hanno la stessa sintassi della variabile stessa: +// * non e' necessario per la dereferenziazione e +// & ("indirizzo di") non e' usato per l'assegnamento. + +using namespace std; + +string foo = "Io sono foo"; +string bar = "Io sono bar"; + + +string& fooRef = foo; // Questo crea un riferimento a foo. +fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento +cout << fooRef; // Stampa "Io sono foo. Ciao!" + +// Non riassegna "fooRef". Questo e' come scrivere "foo = bar", e +// foo == "Io sono bar" +// dopo questa riga. +fooRef = bar; + +const string& barRef = bar; // Crea un riferimento const a bar. +// Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati. +barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati. + +////////////////////////////////////////////////// +// Classi e programmazione orientata agli oggetti +///////////////////////////////////////////////// + +// Primo esempio delle classi +#include + +// Dichiara una classe. +// Le classi sono in genere dichiara in un header file (.h o .hpp). +class Cane { + // Variabili e funzioni membro sono private di default. + std::string nome; + int peso; + +// Tutti i membri dopo questo sono pubblici (public) +// finche' "private:" o "protected:" non compaiono. +public: + + // Costruttore di default + Cane(); + + // Dichiarazioni di funzioni membro (le implentazioni sono a seguito) + // Nota che stiamo usando std::string invece di porre + // using namespace std; + // sopra. + // Mai usare uno statement "using namespace" in uno header. + void impostaNome(const std::string& nomeCane); + + void impostaPeso(int pesoCane); + + // Le funzioni che non modificano lo stato dell'oggetto + // dovrebbero essere marcate come const. + // Questo permette di chiamarle con un riferimento const all'oggetto. + // Inoltre, nota che le funzioni devono essere dichiarate espliciamente come _virtual_ + // per essere sovrascritte in classi derivate. + // Le funzioni non sono virtual di default per motivi di performance. + virtual void print() const; + + // Le funzioni possono essere definite anche all'interno del corpo della classe. + // Le funzioni definite in questo modo sono automaticamente inline. + void abbaia() const { std::cout << nome << " abbaia!\n"; } + + // Assieme con i costruttori, il C++ fornisce i distruttori. + // Questi sono chiamati quando un oggetto e' rimosso o esce dalla visibilita'. + // Questo permette paradigmi potenti come il RAII + // (vedi sotto) + // I distruttori devono essere virtual per permettere a classi di essere derivate da questa. + virtual ~Dog(); + +}; // Un punto e virgola deve seguire la definizione della funzione + +// Class member functions are usually implemented in .cpp files. +void Dog::Dog() +{ + std::cout << "A dog has been constructed\n"; +} + +// Objects (such as strings) should be passed by reference +// if you are modifying them or const reference if you are not. +void Dog::setName(const std::string& dogsName) +{ + name = dogsName; +} + +void Dog::setWeight(int dogsWeight) +{ + weight = dogsWeight; +} + +// Notice that "virtual" is only needed in the declaration, not the definition. +void Dog::print() const +{ + std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; +} + +void Dog::~Dog() +{ + cout << "Goodbye " << name << "\n"; +} + +int main() { + Dog myDog; // prints "A dog has been constructed" + myDog.setName("Barkley"); + myDog.setWeight(10); + myDog.printDog(); // prints "Dog is Barkley and weighs 10 kg" + return 0; +} // prints "Goodbye Barkley" + +// Inheritance: + +// This class inherits everything public and protected from the Dog class +class OwnedDog : public Dog { + + void setOwner(const std::string& dogsOwner) + + // Override the behavior of the print function for all OwnedDogs. See + // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping + // for a more general introduction if you are unfamiliar with + // subtype polymorphism. + // The override keyword is optional but makes sure you are actually + // overriding the method in a base class. + void print() const override; + +private: + std::string owner; +}; + +// Meanwhile, in the corresponding .cpp file: + +void OwnedDog::setOwner(const std::string& dogsOwner) +{ + owner = dogsOwner; +} + +void OwnedDog::print() const +{ + Dog::print(); // Call the print function in the base Dog class + std::cout << "Dog is owned by " << owner << "\n"; + // Prints "Dog is and weights " + // "Dog is owned by " +} + +////////////////////////////////////////// +// Initialization and Operator Overloading +////////////////////////////////////////// + +// In C++ you can overload the behavior of operators such as +, -, *, /, etc. +// This is done by defining a function which is called +// whenever the operator is used. + +#include +using namespace std; + +class Point { +public: + // Member variables can be given default values in this manner. + double x = 0; + double y = 0; + + // Define a default constructor which does nothing + // but initialize the Point to the default value (0, 0) + Point() { }; + + // The following syntax is known as an initialization list + // and is the proper way to initialize class member values + Point (double a, double b) : + x(a), + y(b) + { /* Do nothing except initialize the values */ } + + // Overload the + operator. + Point operator+(const Point& rhs) const; + + // Overload the += operator + Point& operator+=(const Point& rhs); + + // It would also make sense to add the - and -= operators, + // but we will skip those for brevity. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Create a new point that is the sum of this one and rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point up (0,1); + Point right (1,0); + // This calls the Point + operator + // Point up calls the + (function) with right as its paramater + Point result = up + right; + // Prints "Result is upright (1,1)" + cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + return 0; +} + +//////////////////////////// +// Gestione delle eccezioni +/////////////////////////// + +// La libreria standard fornisce un paio di tipi d'eccezioni +// (vedi http://en.cppreference.com/w/cpp/error/exception) +// ma ogni tipo puo' essere lanciato come eccezione +#include + +// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi +// handlers _catch_. +try { + // Non allocare eccezioni nello heap usando _new_. + throw std::exception("E' avvenuto un problema"); +} +// Cattura le eccezioni come riferimenti const se sono oggetti +catch (const std::exception& ex) +{ + std::cout << ex.what(); +// Cattura ogni eccezioni non catturata dal blocco _catch_ precedente +} catch (...) +{ + std::cout << "Catturata un'eccezione sconosciuta"; + throw; // Rilancia l'eccezione +} + +/////// +// RAII +/////// + +// RAII sta per Resource Allocation Is Initialization. +// Spesso viene considerato come il piu' potente paradigma in C++. +// E' un concetto semplice: un costruttore di un oggetto +// acquisisce le risorse di tale oggetto ed il distruttore le rilascia. + +// Per comprendere come questo sia vantaggioso, +// consideriamo una funzione che usa un gestore di file in C: +void faiQualcosaConUnFile(const char* nomefile) +{ + // Per cominciare, assumiamo che niente possa fallire. + + FILE* fh = fopen(nomefile, "r"); // Apri il file in modalita' lettura. + + faiQualcosaConUnFile(fh); + faiQualcosAltroConEsso(fh); + + fclose(fh); // Chiudi il gestore di file. +} + +// Unfortunately, things are quickly complicated by error handling. +// Suppose fopen can fail, and that doSomethingWithTheFile and +// doSomethingElseWithIt return error codes if they fail. +// (Exceptions are the preferred way of handling failure, +// but some programmers, especially those with a C background, +// disagree on the utility of exceptions). +// We now have to check each call for failure and close the file handle +// if a problem occurred. +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Open the file in read mode + if (fh == nullptr) // The returned pointer is null on failure. + return false; // Report that failure to the caller. + + // Assume each function returns false if it failed + if (!doSomethingWithTheFile(fh)) { + fclose(fh); // Close the file handle so it doesn't leak. + return false; // Propagate the error. + } + if (!doSomethingElseWithIt(fh)) { + fclose(fh); // Close the file handle so it doesn't leak. + return false; // Propagate the error. + } + + fclose(fh); // Close the file handle so it doesn't leak. + return true; // Indicate success +} + +// C programmers often clean this up a little bit using goto: +bool doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); + if (fh == nullptr) + return false; + + if (!doSomethingWithTheFile(fh)) + goto failure; + + if (!doSomethingElseWithIt(fh)) + goto failure; + + fclose(fh); // Close the file + return true; // Indicate success + +failure: + fclose(fh); + return false; // Propagate the error +} + +// If the functions indicate errors using exceptions, +// things are a little cleaner, but still sub-optimal. +void doSomethingWithAFile(const char* filename) +{ + FILE* fh = fopen(filename, "r"); // Open the file in read mode + if (fh == nullptr) + throw std::exception("Could not open the file."); + + try { + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + } + catch (...) { + fclose(fh); // Be sure to close the file if an error occurs. + throw; // Then re-throw the exception. + } + + fclose(fh); // Close the file + // Everything succeeded +} + +// Compare this to the use of C++'s file stream class (fstream) +// fstream uses its destructor to close the file. +// Recall from above that destructors are automatically called +// whenever an object falls out of scope. +void doSomethingWithAFile(const std::string& filename) +{ + // ifstream is short for input file stream + std::ifstream fh(filename); // Open the file + + // Do things with the file + doSomethingWithTheFile(fh); + doSomethingElseWithIt(fh); + +} // The file is automatically closed here by the destructor + +// This has _massive_ advantages: +// 1. No matter what happens, +// the resource (in this case the file handle) will be cleaned up. +// Once you write the destructor correctly, +// It is _impossible_ to forget to close the handle and leak the resource. +// 2. Note that the code is much cleaner. +// The destructor handles closing the file behind the scenes +// without you having to worry about it. +// 3. The code is exception safe. +// An exception can be thrown anywhere in the function and cleanup +// will still occur. + +// All idiomatic C++ code uses RAII extensively for all resources. +// Additional examples include +// - Memory using unique_ptr and shared_ptr +// - Containers - the standard library linked list, +// vector (i.e. self-resizing array), hash maps, and so on +// all automatically destroy their contents when they fall out of scope. +// - Mutexes using lock_guard and unique_lock +``` +Letture consigliate: + +Un riferimento aggiornato del linguaggio puo' essere trovato qui + + +Risorse addizionali possono essere trovate qui -- cgit v1.2.3 From 763e7eb224fce450cbf35004d4a5e11e57198cf0 Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Wed, 6 May 2015 11:09:31 -0700 Subject: added and finished C++-it --- it-it/c++-it.html.markdown | 370 ++++++++++++++++++++++----------------------- 1 file changed, 185 insertions(+), 185 deletions(-) (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 8914c234..429c976f 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -9,45 +9,45 @@ translators: lang: it-it --- -Il C++ e' un linguaggio di programmazione il quale, +Il C++ è un linguaggio di programmazione il quale, [secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), -e' stato progettato per +è stato progettato per - essere un "miglior C" - supportare l'astrazione dei dati - supportare la programmazione orientata agli oggetti - supportare la programmazione generica -Nonostante la sintassi possa risultare piu' difficile o complessa di linguaggi piu' recenti, -e' usato in maniera vasta poiche' viene compilato in istruzioni macchina che possono +Nonostante la sintassi possa risultare più difficile o complessa di linguaggi più recenti, +è usato in maniera vasta poichè viene compilato in istruzioni macchina che possono essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C) ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi. -Questa combinazione di velocita' e funzionalita' rende il C++ -uno dei piu' utilizzati linguaggi di programmazione. +Questa combinazione di velocità e funzionalità rende il C++ +uno dei più utilizzati linguaggi di programmazione. ```c++ ////////////////// // Confronto con il C ////////////////// -// Il C++ e' _quasi_ un superset del C e con esso condivide la sintassi di base per +// Il C++ è _quasi_ un superset del C e con esso condivide la sintassi di base per // la dichiarazione di variabili, tipi primitivi, e funzioni. -// Proprio come nel C, l'inizio del programma e' una funzione chiamata +// Proprio come nel C, l'inizio del programma è una funzione chiamata // main con un intero come tipo di ritorno, // nonostante void main() sia anch'essa accettata dalla maggior parte dei compilatori(gcc, clang, ecc...) // Questo valore serve come stato d'uscita del programma. // Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni. int main(int argc, char** argv) { - // Gli argomenti a linea di comando sono passati tramite argc e argv cosi' come + // Gli argomenti a linea di comando sono passati tramite argc e argv così come // avviene in C. // argc indica il numero di argomenti, - // e argv e' un array in stile-C di stringhe (char*) + // e argv è un array in stile-C di stringhe (char*) // che rappresenta gl iargomenti. - // Il primo argomento e' il nome che e' stato assegnato al programma. + // Il primo argomento è il nome che è stato assegnato al programma. // argc e argv possono essere omessi se non hai bisogno di argomenti, - // in questa maniera la funzione avra' int main() come firma. + // in questa maniera la funzione avrà int main() come firma. // Lo stato di uscita 0 indica successo. return 0; @@ -66,7 +66,7 @@ sizeof('c') == sizeof(10) void func(); // funziona che non accetta argomenti // In C -void func(); // funzione che puo' accettare un qualsiasi numero di argomenti +void func(); // funzione che può accettare un qualsiasi numero di argomenti // Usa nullptr invece di NULL in C++ int* ip = nullptr; @@ -95,7 +95,7 @@ void print(char const* myString) void print(int myInt) { - printf("Il mio int e' %d", myInt); + printf("Il mio int è %d", myInt); } int main() @@ -134,7 +134,7 @@ void dichiarazioneInvalida(int a = 1, int b) // Errore! // Namespaces ///////////// -// I namespaces forniscono visibilita' separata per dichiarazioni di variabili, funzioni, +// I namespaces forniscono visibilità separata per dichiarazioni di variabili, funzioni, // ed altro. // I namespaces possono essere annidati. @@ -142,7 +142,7 @@ namespace Primo { namespace Annidato { void foo() { - printf("Questa e' Primo::Annidato::foo\n"); + printf("Questa è Primo::Annidato::foo\n"); } } // fine di namespace Annidato } // fine di namespace Primo @@ -150,13 +150,13 @@ namespace Primo { namespace Secondo { void foo() { - printf("Questa e' Secondo::foo\n") + printf("Questa è Secondo::foo\n") } } void foo() { - printf("Questa e' foo globale\n"); + printf("Questa è foo globale\n"); } int main() @@ -165,9 +165,9 @@ int main() // a meno che non venga dichiarato altrimenti. using namespace Secondo; - foo(); // stampa "Questa e' Secondo::foo" - Primo::Annidato::foo(); // stampa "Questa e' Primo::Annidato::foo" - ::foo(); // stampa "Questa e' foo globale" + foo(); // stampa "Questa è Secondo::foo" + Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo" + ::foo(); // stampa "Questa è foo globale" } /////////////// @@ -176,7 +176,7 @@ int main() // L'input e l'output in C++ utilizza gli streams // cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr. -// << e' l'operatore di inserzione >> e' l'operatore di estrazione. +// << è l'operatore di inserzione >> è l'operatore di estrazione. #include // Include for I/O streams @@ -191,9 +191,9 @@ int main() // Prende l'input cin >> myInt; - // cout puo' anche essere formattato - cout << "Il tuo numero preferito e' " << myInt << "\n"; - // stampa "Il tuo numero preferito e' " + // cout può anche essere formattato + cout << "Il tuo numero preferito è " << myInt << "\n"; + // stampa "Il tuo numero preferito è " cerr << "Usato per messaggi di errore"; } @@ -210,7 +210,7 @@ using namespace std; // Anche le stringhe sono contenute nel namespace std (libr string myString = "Ciao"; string myOtherString = " Mondo"; -// + e' usato per la concatenazione. +// + è usato per la concatenazione. cout << myString + myOtherString; // "Ciao Mondo" cout << myString + " Bella"; // "Ciao Bella" @@ -229,8 +229,8 @@ cout << myString; // "Ciao Mario" // Questi non sono tipi puntatori che non possono essere riassegnati una volta settati // e non possono essere null. // Inoltre, essi hanno la stessa sintassi della variabile stessa: -// * non e' necessario per la dereferenziazione e -// & ("indirizzo di") non e' usato per l'assegnamento. +// * non è necessario per la dereferenziazione e +// & ("indirizzo di") non è usato per l'assegnamento. using namespace std; @@ -242,7 +242,7 @@ string& fooRef = foo; // Questo crea un riferimento a foo. fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento cout << fooRef; // Stampa "Io sono foo. Ciao!" -// Non riassegna "fooRef". Questo e' come scrivere "foo = bar", e +// Non riassegna "fooRef". Questo è come scrivere "foo = bar", e // foo == "Io sono bar" // dopo questa riga. fooRef = bar; @@ -266,7 +266,7 @@ class Cane { int peso; // Tutti i membri dopo questo sono pubblici (public) -// finche' "private:" o "protected:" non compaiono. +// finchè "private:" o "protected:" non compaiono. public: // Costruttore di default @@ -294,7 +294,7 @@ public: void abbaia() const { std::cout << nome << " abbaia!\n"; } // Assieme con i costruttori, il C++ fornisce i distruttori. - // Questi sono chiamati quando un oggetto e' rimosso o esce dalla visibilita'. + // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità. // Questo permette paradigmi potenti come il RAII // (vedi sotto) // I distruttori devono essere virtual per permettere a classi di essere derivate da questa. @@ -302,122 +302,122 @@ public: }; // Un punto e virgola deve seguire la definizione della funzione -// Class member functions are usually implemented in .cpp files. -void Dog::Dog() +// Le funzioni membro di una classe sono generalmente implementate in files .cpp . +void Cane::Cane() { - std::cout << "A dog has been constructed\n"; + std::cout << "Un cane è stato costruito\n"; } -// Objects (such as strings) should be passed by reference -// if you are modifying them or const reference if you are not. -void Dog::setName(const std::string& dogsName) +// Gli oggetti (ad esempio le stringhe) devono essere passati per riferimento +// se li stai modificando o come riferimento const altrimenti. +void Cane::impostaNome(const std::string& nomeCane) { - name = dogsName; + nome = nomeCane; } -void Dog::setWeight(int dogsWeight) +void Cane::impostaPeso(int pesoCane) { - weight = dogsWeight; + peso = pesoCane; } -// Notice that "virtual" is only needed in the declaration, not the definition. -void Dog::print() const +// Notare che "virtual" è solamente necessario nelle dichiarazioni, non nelle definizioni. +void Cane::print() const { - std::cout << "Dog is " << name << " and weighs " << weight << "kg\n"; + std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n"; } -void Dog::~Dog() +void Cane::~Cane() { - cout << "Goodbye " << name << "\n"; + cout << "Ciao ciao " << nome << "\n"; } int main() { - Dog myDog; // prints "A dog has been constructed" - myDog.setName("Barkley"); - myDog.setWeight(10); - myDog.printDog(); // prints "Dog is Barkley and weighs 10 kg" + Cane myDog; // stampa "Un cane è stato costruito" + myDog.impostaNome("Barkley"); + myDog.impostaPeso(10); + myDog.print(); // stampa "Il cane è Barkley e pesa 10 kg" return 0; -} // prints "Goodbye Barkley" +} // stampa "Ciao ciao Barkley" -// Inheritance: +// Ereditarietà: -// This class inherits everything public and protected from the Dog class -class OwnedDog : public Dog { +// Questa classe eredita tutto ciò che è public e protected dalla classe Cane +class MioCane : public Cane { - void setOwner(const std::string& dogsOwner) + void impostaProprietario(const std::string& proprietarioCane) - // Override the behavior of the print function for all OwnedDogs. See - // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping - // for a more general introduction if you are unfamiliar with - // subtype polymorphism. - // The override keyword is optional but makes sure you are actually - // overriding the method in a base class. + // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi + // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29 + // per una introduzione più generale se non sei familiare con + // il polimorfismo. + // La parola chiave override è opzionale ma fa sì che tu stia effettivamente + // sovrascrivendo il metodo nella classe base. void print() const override; private: - std::string owner; + std::string proprietario; }; -// Meanwhile, in the corresponding .cpp file: +// Nel frattempo, nel file .cpp corrispondente: -void OwnedDog::setOwner(const std::string& dogsOwner) +void MioCane::impostaProprietario(const std::string& proprietarioCane) { - owner = dogsOwner; + proprietario = proprietarioCane; } -void OwnedDog::print() const +void MioCane::print() const { - Dog::print(); // Call the print function in the base Dog class - std::cout << "Dog is owned by " << owner << "\n"; - // Prints "Dog is and weights " - // "Dog is owned by " + Cane::print(); // Chiama la funzione print nella classe base Cane + std::cout << "Il cane è di " << proprietario << "\n"; + // stampa "Il cane è e pesa " + // "Il cane è di " } -////////////////////////////////////////// -// Initialization and Operator Overloading -////////////////////////////////////////// +/////////////////////////////////////////////////// +// Inizializzazione ed Overloading degli Operatori +////////////////////////////////////////////////// -// In C++ you can overload the behavior of operators such as +, -, *, /, etc. -// This is done by defining a function which is called -// whenever the operator is used. +// In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc... +// Questo è possibile definendo una funzioneche viene chiamata +// ogniqualvolta l'operatore è usato. #include using namespace std; -class Point { +class Punto { public: - // Member variables can be given default values in this manner. + // Così si assegna alle variabili membro un valore di default. double x = 0; double y = 0; - // Define a default constructor which does nothing - // but initialize the Point to the default value (0, 0) - Point() { }; + // Definisce un costruttore di default che non fa nulla + // ma inizializza il Punto ai valori di default (0, 0) + Punto() { }; - // The following syntax is known as an initialization list - // and is the proper way to initialize class member values - Point (double a, double b) : + // La sintassi seguente è nota come lista di inizializzazione + // ed è il modo appropriato di inizializzare i valori membro della classe + Punto (double a, double b) : x(a), y(b) - { /* Do nothing except initialize the values */ } + { /* Non fa nulla eccetto inizializzare i valori */ } - // Overload the + operator. - Point operator+(const Point& rhs) const; + // Sovrascrivi l'operatore +. + Punto operator+(const Punto& rhs) const; - // Overload the += operator - Point& operator+=(const Point& rhs); + // Sovrascrivi l'operatore += + Punto& operator+=(const Punto& rhs); - // It would also make sense to add the - and -= operators, - // but we will skip those for brevity. + // Avrebbe senso aggiungere gli operatori - e -=, + // ma li saltiamo per rendere la guida più breve. }; -Point Point::operator+(const Point& rhs) const +Punto Punto::operator+(const Punto& rhs) const { - // Create a new point that is the sum of this one and rhs. - return Point(x + rhs.x, y + rhs.y); + // Crea un nuovo punto come somma di questo e di rhs. + return Punto(x + rhs.x, y + rhs.y); } -Point& Point::operator+=(const Point& rhs) +Punto& Punto::operator+=(const Punto& rhs) { x += rhs.x; y += rhs.y; @@ -425,13 +425,13 @@ Point& Point::operator+=(const Point& rhs) } int main () { - Point up (0,1); - Point right (1,0); - // This calls the Point + operator - // Point up calls the + (function) with right as its paramater - Point result = up + right; - // Prints "Result is upright (1,1)" - cout << "Result is upright (" << result.x << ',' << result.y << ")\n"; + Punto su (0,1); + Punto destro (1,0); + // Questo chiama l'operatore + di Punto + // Il Punto su chiama la funzione + con destro come argomento + Punto risultato = su + destro; + // Stampa "Risultato è spostato in (1,1)" + cout << "Risultato è spostato (" << risultato.x << ',' << risultato.y << ")\n"; return 0; } @@ -441,14 +441,14 @@ int main () { // La libreria standard fornisce un paio di tipi d'eccezioni // (vedi http://en.cppreference.com/w/cpp/error/exception) -// ma ogni tipo puo' essere lanciato come eccezione +// ma ogni tipo può essere lanciato come eccezione #include // Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi // handlers _catch_. try { // Non allocare eccezioni nello heap usando _new_. - throw std::exception("E' avvenuto un problema"); + throw std::exception("È avvenuto un problema"); } // Cattura le eccezioni come riferimenti const se sono oggetti catch (const std::exception& ex) @@ -466,8 +466,8 @@ catch (const std::exception& ex) /////// // RAII sta per Resource Allocation Is Initialization. -// Spesso viene considerato come il piu' potente paradigma in C++. -// E' un concetto semplice: un costruttore di un oggetto +// Spesso viene considerato come il più potente paradigma in C++. +// È un concetto semplice: un costruttore di un oggetto // acquisisce le risorse di tale oggetto ed il distruttore le rilascia. // Per comprendere come questo sia vantaggioso, @@ -476,122 +476,122 @@ void faiQualcosaConUnFile(const char* nomefile) { // Per cominciare, assumiamo che niente possa fallire. - FILE* fh = fopen(nomefile, "r"); // Apri il file in modalita' lettura. + FILE* fh = fopen(nomefile, "r"); // Apri il file in modalità lettura. - faiQualcosaConUnFile(fh); + faiQualcosaConIlFile(fh); faiQualcosAltroConEsso(fh); fclose(fh); // Chiudi il gestore di file. } -// Unfortunately, things are quickly complicated by error handling. -// Suppose fopen can fail, and that doSomethingWithTheFile and -// doSomethingElseWithIt return error codes if they fail. -// (Exceptions are the preferred way of handling failure, -// but some programmers, especially those with a C background, -// disagree on the utility of exceptions). -// We now have to check each call for failure and close the file handle -// if a problem occurred. -bool doSomethingWithAFile(const char* filename) +// Sfortunatamente, le cose vengono complicate dalla gestione degli errori. +// Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e +// faiQualcosAltroConEsso ritornano codici d'errore se falliscono. +// (Le eccezioni sono la maniera preferita per gestire i fallimenti, +// ma alcuni programmatori, specialmente quelli con un passato in C, +// non sono d'accordo con l'utilità delle eccezioni). +// Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file +// se un problema è avvenuto. +bool faiQualcosaConUnFile(const char* nomefile) { - FILE* fh = fopen(filename, "r"); // Open the file in read mode - if (fh == nullptr) // The returned pointer is null on failure. - return false; // Report that failure to the caller. - - // Assume each function returns false if it failed - if (!doSomethingWithTheFile(fh)) { - fclose(fh); // Close the file handle so it doesn't leak. - return false; // Propagate the error. + FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura + if (fh == nullptr) // Il puntatore restituito è null in caso di fallimento. + return false; // Riporta il fallimento al chiamante. + + // Assumiamo che ogni funzione ritorni false se ha fallito + if (!faiQualcosaConIlFile(fh)) { + fclose(fh); // Chiude il gestore di file così che non sprechi memoria. + return false; // Propaga l'errore. } - if (!doSomethingElseWithIt(fh)) { - fclose(fh); // Close the file handle so it doesn't leak. - return false; // Propagate the error. + if (!faiQualcosAltroConEsso(fh)) { + fclose(fh); // Chiude il gestore di file così che non sprechi memoria. + return false; // Propaga l'errore. } - fclose(fh); // Close the file handle so it doesn't leak. - return true; // Indicate success + fclose(fh); // Chiudi il gestore di file così che non sprechi memoria. + return true; // Indica successo } -// C programmers often clean this up a little bit using goto: -bool doSomethingWithAFile(const char* filename) +// I programmatori C in genere puliscono questa procedura usando goto: +bool faiQualcosaConUnFile(const char* nomefile) { - FILE* fh = fopen(filename, "r"); + FILE* fh = fopen(nomefile, "r"); if (fh == nullptr) return false; - if (!doSomethingWithTheFile(fh)) - goto failure; + if (!faiQualcosaConIlFile(fh)) + goto fallimento; - if (!doSomethingElseWithIt(fh)) - goto failure; + if (!faiQualcosAltroConEsso(fh)) + goto fallimento; - fclose(fh); // Close the file - return true; // Indicate success + fclose(fh); // Chiude il file + return true; // Indica successo -failure: +fallimento: fclose(fh); - return false; // Propagate the error + return false; // Propaga l'errore } -// If the functions indicate errors using exceptions, -// things are a little cleaner, but still sub-optimal. -void doSomethingWithAFile(const char* filename) +// Se le funzioni indicano errori usando le eccezioni, +// le cose sono un pò più pulite, ma sono sempre sub-ottimali. +void faiQualcosaConUnFile(const char* nomefile) { - FILE* fh = fopen(filename, "r"); // Open the file in read mode + FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura if (fh == nullptr) - throw std::exception("Could not open the file."); + throw std::exception("Non è stato possibile aprire il file."). try { - doSomethingWithTheFile(fh); - doSomethingElseWithIt(fh); + faiQualcosaConIlFile(fh); + faiQualcosAltroConEsso(fh); } catch (...) { - fclose(fh); // Be sure to close the file if an error occurs. - throw; // Then re-throw the exception. + fclose(fh); // Fai sì che il file venga chiuso se si ha un errore. + throw; // Poi rilancia l'eccezione. } - fclose(fh); // Close the file - // Everything succeeded + fclose(fh); // Chiudi il file + // Tutto è andato bene } -// Compare this to the use of C++'s file stream class (fstream) -// fstream uses its destructor to close the file. -// Recall from above that destructors are automatically called -// whenever an object falls out of scope. -void doSomethingWithAFile(const std::string& filename) +// Confronta questo con l'utilizzo della classe C++ file stream (fstream) +// fstream usa i distruttori per chiudere il file. +// Come detto sopra, i distruttori sono automaticamente chiamati +// ogniqualvolta un oggetto esce dalla visibilità. +void faiQualcosaConUnFile(const std::string& nomefile) { - // ifstream is short for input file stream - std::ifstream fh(filename); // Open the file - - // Do things with the file - doSomethingWithTheFile(fh); - doSomethingElseWithIt(fh); - -} // The file is automatically closed here by the destructor - -// This has _massive_ advantages: -// 1. No matter what happens, -// the resource (in this case the file handle) will be cleaned up. -// Once you write the destructor correctly, -// It is _impossible_ to forget to close the handle and leak the resource. -// 2. Note that the code is much cleaner. -// The destructor handles closing the file behind the scenes -// without you having to worry about it. -// 3. The code is exception safe. -// An exception can be thrown anywhere in the function and cleanup -// will still occur. - -// All idiomatic C++ code uses RAII extensively for all resources. -// Additional examples include -// - Memory using unique_ptr and shared_ptr -// - Containers - the standard library linked list, -// vector (i.e. self-resizing array), hash maps, and so on -// all automatically destroy their contents when they fall out of scope. -// - Mutexes using lock_guard and unique_lock + // ifstream è l'abbreviazione di input file stream + std::ifstream fh(nomefile); // Apre il file + + // Fai qualcosa con il file + faiQualcosaConIlFile(fh); + faiQualcosAltroConEsso(fh); + +} // Il file viene chiuso automaticamente chiuso qui dal distruttore + +// Questo ha vantaggi _enormi_: +// 1. Può succedere di tutto ma +// la risorsa (in questo caso il file handler) verrà ripulito. +// Una volta che scrivi il distruttore correttamente, +// È _impossibile_ scordarsi di chiudere l'handler e sprecare memoria. +// 2. Nota che il codice è molto più pulito. +// Il distruttore gestisce la chiusura del file dietro le scene +// senza che tu debba preoccupartene. +// 3. Il codice è sicuro da eccezioni. +// Una eccezione può essere lanciata in qualunque punto nella funzione e la ripulitura +// avverrà lo stesso. + +// Tutto il codice C++ idiomatico usa RAII in maniera vasta su tutte le risorse. +// Esempi aggiuntivi includono +// - Utilizzo della memoria con unique_ptr e shared_ptr +// - I contenitori - la lista della libreria standard, +// vettori (i.e. array auto-aggiustati), mappe hash, e così via +// sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità. +// - I mutex usano lock_guard e unique_lock ``` Letture consigliate: -Un riferimento aggiornato del linguaggio puo' essere trovato qui +Un riferimento aggiornato del linguaggio può essere trovato qui Risorse addizionali possono essere trovate qui -- cgit v1.2.3 From e6900d270be10d1516a8ea32f208bba2d8611e4f Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Sat, 9 May 2015 14:54:19 -0700 Subject: C++ italian is up to date --- it-it/c++-it.html.markdown | 125 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 124 insertions(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 429c976f..39afced5 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -35,7 +35,6 @@ uno dei più utilizzati linguaggi di programmazione. // Proprio come nel C, l'inizio del programma è una funzione chiamata // main con un intero come tipo di ritorno, -// nonostante void main() sia anch'essa accettata dalla maggior parte dei compilatori(gcc, clang, ecc...) // Questo valore serve come stato d'uscita del programma. // Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni. int main(int argc, char** argv) @@ -435,6 +434,83 @@ int main () { return 0; } +///////////////// +// Templates +//////////////// + +// Generalmente i templates in C++ sono utilizzati per programmazione generica, anche se +// sono molto più potenti dei costrutti generici in altri linguaggi. Inoltre, +// supportano specializzazione esplicita e parziale, classi in stile funzionale, +// e sono anche complete per Turing. + +// Iniziamo con il tipo di programmazione generica con cui forse sei familiare. Per +// definire una classe o una funzione che prende un parametro di un dato tipo: +template +class Box { + // In questa classe, T può essere usato come qualsiasi tipo. + void inserisci(const T&) { ... } +}; + +// Durante la compilazione, il compilatore in effetti genera copie di ogni template +// con i parametri sostituiti, e così la definizione completa della classe deve essere +// presente ad ogni invocazione. Questo è il motivo per cui vedrai le classi template definite +// interamente in header files. + +// Per instanziare una classe template sullo stack: +Box intBox; + +// e puoi usarla come aspettato: +intBox.inserisci(123); + +//Puoi, ovviamente, innestare i templates: +Box > boxOfBox; +boxOfBox.inserisci(intBox); + +// Fino al C++11, devi porre uno spazio tra le due '>', altrimenti '>>' +// viene visto come l'operatore di shift destro. + +// Qualche volta vedrai +// template +// invece. La parole chiavi 'class' e 'typename' sono _generalmente_ +// intercambiabili in questo caso. Per una spiegazione completa, vedi +// http://en.wikipedia.org/wiki/Typename +// (si, quella parola chiave ha una sua pagina di Wikipedia propria). + +// Similmente, una funzione template: +template +void abbaiaTreVolte(const T& input) +{ + input.abbaia(); + input.abbaia(); + input.abbaia(); +} + +// Nota che niente è specificato relativamente al tipo di parametri. Il compilatore +// genererà e poi verificherà il tipo di ogni invocazione del template, così che +// la funzione di cui sopra funzione con ogni tipo 'T' che ha const 'abbaia' come metodo! + +Cane fluffy; +fluffy.impostaNome("Fluffy") +abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia tre volte. + +// I parametri template non devono essere classi: +template +void stampaMessaggio() { + cout << "Impara il C++ in " << Y << " minuti!" << endl; +} + +// E poi esplicitamente specializzare i template per avere codice più efficiente. Ovviamente, +// la maggior parte delle casistiche reali non sono così triviali. +// Notare che avrai comunque bisogna di dichiarare la funzione (o classe) come un template +// anche se hai esplicitamente specificato tutti i parametri. +template<> +void stampaMessaggio<10>() { + cout << "Impara il C++ più velocemente in soli 10 minuti!" << endl; +} + +printMessage<20>(); // Stampa "impara il C++ in 20 minuti!" +printMessage<10>(); // Stampa "Impara il C++ più velocemente in soli 10 minuti!" + //////////////////////////// // Gestione delle eccezioni /////////////////////////// @@ -588,6 +664,53 @@ void faiQualcosaConUnFile(const std::string& nomefile) // vettori (i.e. array auto-aggiustati), mappe hash, e così via // sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità. // - I mutex usano lock_guard e unique_lock + +/////////////////////// +// Roba divertente +////////////////////// + +// Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano). +// Questa sezione è, fortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi +// più facili con cui puoi spararti da solo nel piede. + +// Puoi sovrascrivere metodi privati! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // sovrascrive Foo::bar! +}; + + +// 0 == false == NULL (la maggior parte delle volte)! +bool* pt = new bool; +*pt = 0; // Setta il valore puntato da 'pt' come falso. +pt = 0; // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings. + +// nullptr dovrebbe risolvere alcune di quei problemi: +int* pt2 = new int; +*pt2 = nullptr; // Non compila +pt2 = nullptr; // Setta pt2 a null. + +// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`. +*pt = nullptr; // Questo compila, anche se '*pt' è un bool! + + +// '=' != '=' != '='! +// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia. +Foo f2; +Foo f1 = f2; + +// Chiama Foo::Foo(const Foo&) o qualche variante, ma solo copie di 'Foo' che fanno parte di +// 'fooSub'. Ogni altro membro di 'fooSub' viene scartato. Questo comportamento +// orribile viene chiamato "object slicing." +FooSub fooSub; +Foo f1 = fooSub; + +// Chiama Foo::operator=(Foo&) o una sua variante. +Foo f1; +f1 = f2; + ``` Letture consigliate: -- cgit v1.2.3 From 9311ca75afcc2338a03980b800f4f1eaa40bee8c Mon Sep 17 00:00:00 2001 From: robertmargelli Date: Sat, 9 May 2015 19:18:04 -0700 Subject: fixed C++/it typos --- it-it/c++-it.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 39afced5..4f5ac8a2 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -42,8 +42,8 @@ int main(int argc, char** argv) // Gli argomenti a linea di comando sono passati tramite argc e argv così come // avviene in C. // argc indica il numero di argomenti, - // e argv è un array in stile-C di stringhe (char*) - // che rappresenta gl iargomenti. + // e argv è un array di stringhe in stile-C (char*) + // che rappresenta gli argomenti. // Il primo argomento è il nome che è stato assegnato al programma. // argc e argv possono essere omessi se non hai bisogno di argomenti, // in questa maniera la funzione avrà int main() come firma. @@ -177,7 +177,7 @@ int main() // cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr. // << è l'operatore di inserzione >> è l'operatore di estrazione. -#include // Include for I/O streams +#include // Include gli streams di I/O using namespace std; // Gli streams sono nel namespace std (libreria standard) @@ -377,7 +377,7 @@ void MioCane::print() const ////////////////////////////////////////////////// // In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc... -// Questo è possibile definendo una funzioneche viene chiamata +// Questo è possibile definendo una funzione che viene chiamata // ogniqualvolta l'operatore è usato. #include @@ -491,7 +491,7 @@ void abbaiaTreVolte(const T& input) Cane fluffy; fluffy.impostaNome("Fluffy") -abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia tre volte. +abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia" tre volte. // I parametri template non devono essere classi: template @@ -670,7 +670,7 @@ void faiQualcosaConUnFile(const std::string& nomefile) ////////////////////// // Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano). -// Questa sezione è, fortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi +// Questa sezione è, sfortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi // più facili con cui puoi spararti da solo nel piede. // Puoi sovrascrivere metodi privati! -- cgit v1.2.3 From 68b05bcc518064dab26c5098ea369a71bb9b5d8e Mon Sep 17 00:00:00 2001 From: ven Date: Wed, 17 Jun 2015 23:25:16 +0200 Subject: Fix adambard/learnxinyminutes-site#12 --- it-it/c++-it.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 4f5ac8a2..e7e1d89e 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -1,6 +1,6 @@ --- language: c++ -filename: learncpp.cpp +filename: learncpp-it.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] - ["Matt Kline", "https://github.com/mrkline"] -- cgit v1.2.3 From 0cd643e07217d29f6e22a8368f5a098b65d37f7e Mon Sep 17 00:00:00 2001 From: Luca Maroni Date: Fri, 18 Sep 2015 09:54:37 +0200 Subject: added Elixir --- it-it/elixir-it.html.markdown | 418 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 418 insertions(+) create mode 100644 it-it/elixir-it.html.markdown (limited to 'it-it') diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown new file mode 100644 index 00000000..f5d0c172 --- /dev/null +++ b/it-it/elixir-it.html.markdown @@ -0,0 +1,418 @@ +--- +language: elixir +contributors: + - ["Luca 'Kino' Maroni", "https://github.com/kino90"] + - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] +filename: learnelixir-it.ex +lang: it-it +--- + +Elixir è un linguaggio funzionale moderno, costruito sulla VM Erlang. +È totalmente compatibile con Erlang, ma con una sintassi più standard +e molte altre funzionalità. + +```elixir + +# I commenti su una riga iniziano con un cancelletto. + +# Non esistono commenti multilinea, +# ma puoi concatenare più commenti. + +# Per usare la shell di elixir usa il comando `iex`. +# Compila i tuoi moduli con il comando `elixirc`. + +# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato +# elixir correttamente. + +## --------------------------- +## -- Tipi di base +## --------------------------- + +# Numeri +3 # intero (Integer) +0x1F # intero +3.0 # decimale (Float) + +# Atomi, che sono literals, una costante con un nome. Iniziano con `:`. +:ciao # atomo (Atom) + +# Tuple che sono salvate in celle di memoria contigue. +{1,2,3} # tupla (Tuple) + +# Possiamo accedere ad un elemento di una tupla con la funzione `elem`: +elem({1, 2, 3}, 0) #=> 1 + +# Liste, che sono implementate come liste concatenate (o linked list). +[1,2,3] # lista (List) + +# Possiamo accedere alla testa (head) e alla coda (tail) delle liste così: +[testa | coda] = [1,2,3] +testa #=> 1 +coda #=> [2,3] + +# In Elixir, proprio come in Erlang, il simbolo `=` denota pattern matching e +# non un assegnamento. +# +# Questo significa che la parte sinistra (pattern) viene confrontata alla +# parte destra. +# +# Questo spiega il funzionamento dell'esempio dell'accesso alla lista di prima. + +# Un pattern match darà errore quando le parti non combaciano, ad esempio se +# le tuple hanno dimensione differente. +# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} + +# Ci sono anche i binari +<<1,2,3>> # binari (Binary) + +# Stringhe e liste di caratteri +"ciao" # stringa (String) +'ciao' # lista di caratteri (List) + +# Stringhe multilinea +""" +Sono una stringa +multi-linea. +""" +#=> "Sono una stringa\nmulti-linea.\n" + +# Le stringhe sono tutte codificate in UTF-8: +"cìaò" +#=> "cìaò" + +# le stringhe in realtà sono dei binari, e le liste di caratteri sono liste. +<> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# `?a` in elixir restituisce il valore ASCII della lettera `a` +?a #=> 97 + +# Per concatenare liste si usa `++`, per binari si usa `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'ciao ' ++ 'mondo' #=> 'ciao mondo' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"ciao " <> "mondo" #=> "ciao mondo" + +# Gli intervalli sono rappresentati come `inizio..fine` (estremi inclusi) +1..10 #=> 1..10 (Range) +minore..maggiore = 1..10 # Puoi fare pattern matching anche sugli intervalli +[minore, maggiore] #=> [1, 10] + +## --------------------------- +## -- Operatori +## --------------------------- + +# Un po' di matematica +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# In elixir l'operatore `/` restituisce sempre un decimale. + +# Per fare una divisione intera si usa `div` +div(10, 2) #=> 5 + +# Per ottenere il resto di una divisione si usa `rem` +rem(10, 3) #=> 1 + +# Ci sono anche gli operatori booleani: `or`, `and` e `not`. +# Questi operatori si aspettano un booleano come primo argomento. +true and true #=> true +false or true #=> true +# 1 and true #=> ** (ArgumentError) argument error + +# Elixir fornisce anche `||`, `&&` e `!` che accettano argomenti +# di qualsiasi tipo. +# Tutti i valori tranne `false` e `nil` saranno valutati come true. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil +!true #=> false + +# Per i confronti abbiamo: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` e `!==` sono più rigidi quando si confrontano interi e decimali: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# Possiamo anche confrontare tipi di dato diversi: +1 < :ciao #=> true + +# L'ordine generale è definito sotto: +# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste +# < stringhe di bit + +# Per citare Joe Armstrong su questo: "L'ordine non è importante, +# ma è importante che sia definito un ordine." + +## --------------------------- +## -- Controllo di flusso +## --------------------------- + +# espressione `se` (`if`) +if false do + "Questo non si vedrà mai" +else + "Questo sì" +end + +# c'è anche un `se non` (`unless`) +unless true do + "Questo non si vedrà mai" +else + "Questo sì" +end + +# Ti ricordi il pattern matching? +# Moltre strutture di controllo di flusso in elixir si basano su di esso. + +# `case` ci permette di confrontare un valore a diversi pattern: +case {:uno, :due} do + {:quattro, :cinque} -> + "Questo non farà match" + {:uno, x} -> + "Questo farà match e binderà `x` a `:due`" + _ -> + "Questo farà match con qualsiasi valore" +end + +# Solitamente si usa `_` se non si ha bisogno di utilizzare un valore. +# Ad esempio, se ci serve solo la testa di una lista: +[testa | _] = [1,2,3] +testa #=> 1 + +# Per aumentare la leggibilità possiamo usarlo in questo modo: +[testa | _coda] = [:a, :b, :c] +testa #=> :a + +# `cond` ci permette di verificare più condizioni allo stesso momento. +# Usa `cond` invece di innestare più espressioni `if`. +cond do + 1 + 1 == 3 -> + "Questa stringa non si vedrà mai" + 2 * 5 == 12 -> + "Nemmeno questa" + 1 + 2 == 3 -> + "Questa sì!" +end + +# È pratica comune mettere l'ultima condizione a `true`, che farà sempre match +cond do + 1 + 1 == 3 -> + "Questa stringa non si vedrà mai" + 2 * 5 == 12 -> + "Nemmeno questa" + true -> + "Questa sì! (essenzialmente funziona come un else)" +end + +# `try/catch` si usa per gestire i valori lanciati (throw), +# Supporta anche una clausola `after` che è invocata in ogni caso. +try do + throw(:ciao) +catch + message -> "Ho ricevuto #{message}." +after + IO.puts("Io sono la clausola 'after'.") +end +#=> Io sono la clausola 'after' +# "Ho ricevuto :ciao" + +## --------------------------- +## -- Moduli e Funzioni +## --------------------------- + +# Funzioni anonime (notare il punto) +quadrato = fn(x) -> x * x end +quadrato.(5) #=> 25 + +# Accettano anche guardie e condizioni multiple. +# le guardie ti permettono di perfezionare il tuo pattern matching, +# sono indicate dalla parola chiave `when`: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir fornisce anche molte funzioni, disponibili nello scope corrente. +is_number(10) #=> true +is_list("ciao") #=> false +elem({1,2,3}, 0) #=> 1 + +# Puoi raggruppare delle funzioni all'interno di un modulo. +# All'interno di un modulo usa `def` per definire le tue funzioni. +defmodule Matematica do + def somma(a, b) do + a + b + end + + def quadrato(x) do + x * x + end +end + +Matematica.somma(1, 2) #=> 3 +Matematica.quadrato(3) #=> 9 + +# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa +# `elixirc`. +# nel tuo terminale: elixirc matematica.ex + +# All'interno di un modulo possiamo definire le funzioni con `def` e funzioni +# private con `defp`. +# Una funzione definita con `def` è disponibile per essere invocata anche da +# altri moduli, una funziona privata può essere invocata solo localmente. +defmodule MatematicaPrivata do + def somma(a, b) do + esegui_somma(a, b) + end + + defp esegui_somma(a, b) do + a + b + end +end + +MatematicaPrivata.somma(1, 2) #=> 3 +# MatematicaPrivata.esegui_somma(1, 2) #=> ** (UndefinedFunctionError) + +# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple: +defmodule Geometria do + def area({:rettangolo, w, h}) do + w * h + end + + def area({:cerchio, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometria.area({:rettangolo, 2, 3}) #=> 6 +Geometria.area({:cerchio, 3}) #=> 28.25999999999999801048 +# Geometria.area({:cerchio, "non_un_numero"}) +#=> ** (FunctionClauseError) no function clause matching in Geometria.area/1 + +# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in elixir +defmodule Ricorsione do + def somma_lista([testa | coda], accumulatore) do + somma_lista(coda, accumulatore + testa) + end + + def somma_lista([], accumulatore) do + accumulatore + end +end + +Ricorsione.somma_lista([1,2,3], 0) #=> 6 + +# I moduli di Elixir supportano attributi. Ci sono degli attributi incorporati +# e puoi anche aggiungerne di personalizzati. +defmodule Modulo do + @moduledoc """ + Questo è un attributo incorporato in un modulo di esempio. + """ + + @miei_dati 100 # Questo è un attributo personalizzato . + IO.inspect(@miei_dati) #=> 100 +end + +## --------------------------- +## -- Strutture ed Eccezioni +## --------------------------- + + +# Le Strutture (Structs) sono estensioni alle mappe che portano +# valori di default, garanzia alla compilazione e polimorfismo in Elixir. +defmodule Persona do + defstruct nome: nil, eta: 0, altezza: 0 +end + +luca = %Persona{ nome: "Luca", eta: 24, altezza: 185 } +#=> %Persona{eta: 24, altezza: 185, nome: "Luca"} + +# Legge al valore di 'nome' +luca.nome #=> "Luca" + +# Modifica il valore di eta +luca_invecchiato = %{ luca | eta: 25 } +#=> %Persona{eta: 25, altezza: 185, nome: "Luca"} + +# Il blocco `try` con la parola chiave `rescue` è usato per gestire le eccezioni +try do + raise "un errore" +rescue + RuntimeError -> "Salvato un errore di Runtime" + _error -> "Questo salverà da qualsiasi errore" +end + +# Tutte le eccezioni hanno un messaggio +try do + raise "un errore" +rescue + x in [RuntimeError] -> + x.message +end + +## --------------------------- +## -- Concorrenza +## --------------------------- + +# Elixir si basa sul modello degli attori per la concorrenza. +# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir +# sono tre primitive: creare processi, inviare messaggi e ricevere messaggi. + +# Per creare un nuovo processo si usa la funzione `spawn`, che riceve una +# funzione come argomento. +f = fn -> 2 * 2 end #=> #Function +spawn(f) #=> #PID<0.40.0> + +# `spawn` restituisce un pid (identificatore di processo). Puoi usare questo +# pid per inviare messaggi al processo. +# Per passare messaggi si usa l'operatore `send`. +# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi, +# oltre ad inviarli. Questo è realizzabile con `receive`: +defmodule Geometria do + def calcolo_area do + receive do + {:rettangolo, w, h} -> + IO.puts("Area = #{w * h}") + calcolo_area() + {:cerchio, r} -> + IO.puts("Area = #{3.14 * r * r}") + calcolo_area() + end + end +end + +# Compila il modulo e crea un processo che esegue `calcolo_area` nella shell +pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0> + +# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive +send pid, {:rettangolo, 2, 3} +#=> Area = 6 +# {:rettangolo,2,3} + +send pid, {:cerchio, 2} +#=> Area = 12.56000000000000049738 +# {:cerchio,2} + +# Anche la shell è un processo. Puoi usare `self` per ottenere il pid corrente +self() #=> #PID<0.27.0> +``` + +## Referenze + +* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org) +* [Documentazione Elixir](http://elixir-lang.org/docs/master/) +* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas +* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) di Fred Hebert +* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) di Joe Armstrong -- cgit v1.2.3 From cb728dc4d3117fdefe91713a8d0d129d48ad7e1d Mon Sep 17 00:00:00 2001 From: Luca Maroni Date: Fri, 18 Sep 2015 09:57:04 +0200 Subject: Added coffeescript --- it-it/coffeescript-it.html.markdown | 102 ++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 it-it/coffeescript-it.html.markdown (limited to 'it-it') diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown new file mode 100644 index 00000000..c4bc8ea9 --- /dev/null +++ b/it-it/coffeescript-it.html.markdown @@ -0,0 +1,102 @@ +--- +language: coffeescript +contributors: + - ["Luca 'Kino' Maroni", "http://github.com/kino90"] + - ["Tenor Biel", "http://github.com/L8D"] + - ["Xavier Yao", "http://github.com/xavieryao"] +filename: coffeescript-it.coffee +lang: it-it +--- + +CoffeeScript è un piccolo linguaggio che compila direttamente nell'equivalente JavaScript, non c'è nessuna interpretazione a runtime. Come possibile successore di Javascript, CoffeeScript fa il suo meglio per restituire un codice leggibile, ben stampato e performante in ogni ambiente JavaScript. + +Guarda anche [il sito di CoffeeScript](http://coffeescript.org/), che ha una guida completa a CoffeeScript. + +```coffeescript +# CoffeeScript è un linguaggio hipster. +# Segue le mode di alcuni linguaggi moderni. +# Quindi i commenti sono come quelli di Ruby e Python, usano l'asterisco. + +### +I blocchi di commenti sono definiti con tre cancelletti, che vengono tradotti direttamente in `/*` e `*/` nel codice JavaScript risultante. + +Prima di continuare devi conoscere la maggior parte +delle semantiche JavaScript. +### + +# Assegnamento: +numero = 42 #=> var numero = 42; +contrario = true #=> var contrario = true; + +# Condizioni: +numero = -42 if contrario #=> if(contrario) { numero = -42; } + +# Funzioni: +quadrato = (x) -> x * x #=> var quadrato = function(x) { return x * x; } + +riempi = (contenitore, liquido = "caffè") -> + "Sto riempiendo #{contenitore} con #{liquido}..." +#=>var riempi; +# +#riempi = function(contenitore, liquido) { +# if (liquido == null) { +# liquido = "caffè"; +# } +# return "Sto riempiendo " + contenitore + " con " + liquido + "..."; +#}; + +# Intervalli: +lista = [1..5] #=> var lista = [1, 2, 3, 4, 5]; + +# Oggetti: +matematica = + radice: Math.sqrt + quadrato: quadrato + cubo: (x) -> x * quadrato x +#=> var matematica = { +# "radice": Math.sqrt, +# "quadrato": quadrato, +# "cubo": function(x) { return x * quadrato(x); } +#} + +# Splats: +gara = (vincitore, partecipanti...) -> + print vincitore, partecipanti +#=>gara = function() { +# var partecipanti, vincitore; +# vincitore = arguments[0], partecipanti = 2 <= arguments.length ? __slice.call(arguments, 1) : []; +# return print(vincitore, partecipanti); +#}; + +# Esistenza: +alert "Lo sapevo!" if elvis? +#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Lo sapevo!"); } + +# Comprensione degli Array: +cubi = (matematica.cubo num for num in lista) +#=>cubi = (function() { +# var _i, _len, _results; +# _results = []; +# for (_i = 0, _len = lista.length; _i < _len; _i++) { +# num = lista[_i]; +# _results.push(matematica.cubo(num)); +# } +# return _results; +# })(); + +cibi = ['broccoli', 'spinaci', 'cioccolato'] +mangia cibo for cibo in cibi when cibo isnt 'cioccolato' +#=>cibi = ['broccoli', 'spinaci', 'cioccolato']; +# +#for (_k = 0, _len2 = cibi.length; _k < _len2; _k++) { +# cibo = cibi[_k]; +# if (cibo !== 'cioccolato') { +# mangia(cibo); +# } +#} +``` + +## Altre risorse + +- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/) +- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read) -- cgit v1.2.3 From 52b217af04589faac6298f38302c4fad2b33542c Mon Sep 17 00:00:00 2001 From: Luca Maroni Date: Sun, 20 Sep 2015 02:06:53 +0200 Subject: Fixed lines too long and a typo (asterisco => cancelletto) --- it-it/coffeescript-it.html.markdown | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'it-it') diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown index c4bc8ea9..16eb9bd4 100644 --- a/it-it/coffeescript-it.html.markdown +++ b/it-it/coffeescript-it.html.markdown @@ -8,17 +8,22 @@ filename: coffeescript-it.coffee lang: it-it --- -CoffeeScript è un piccolo linguaggio che compila direttamente nell'equivalente JavaScript, non c'è nessuna interpretazione a runtime. Come possibile successore di Javascript, CoffeeScript fa il suo meglio per restituire un codice leggibile, ben stampato e performante in ogni ambiente JavaScript. +CoffeeScript è un piccolo linguaggio che compila direttamente nell'equivalente +JavaScript, non c'è nessuna interpretazione a runtime. Come possibile +successore di Javascript, CoffeeScript fa il suo meglio per restituire +un codice leggibile, ben stampato e performante in ogni ambiente JavaScript. -Guarda anche [il sito di CoffeeScript](http://coffeescript.org/), che ha una guida completa a CoffeeScript. +Guarda anche [il sito di CoffeeScript](http://coffeescript.org/), che ha una +guida completa a CoffeeScript. ```coffeescript # CoffeeScript è un linguaggio hipster. # Segue le mode di alcuni linguaggi moderni. -# Quindi i commenti sono come quelli di Ruby e Python, usano l'asterisco. +# Quindi i commenti sono come quelli di Ruby e Python, usano il cancelletto. ### -I blocchi di commenti sono definiti con tre cancelletti, che vengono tradotti direttamente in `/*` e `*/` nel codice JavaScript risultante. +I blocchi di commenti sono definiti con tre cancelletti, che vengono tradotti +direttamente in `/*` e `*/` nel codice JavaScript risultante. Prima di continuare devi conoscere la maggior parte delle semantiche JavaScript. -- cgit v1.2.3