Scritto da phoby www.erroredigitale.tk ultima modifica : 25 Maggio 2006 Visitate www.erroredigitale.tk [under costruction] per altro materiale relativo a programmazione, linux, hacking, security, etc... Il corso e' a puntate e trattera' in maniera completa il linguaggio java... enjoy ;) prima puntata ------------- premessa: in questa prima puntata cerchero' di dare una breve panoramica, che verra' ripresa passo a passo (partendo dalle variabili per intenderci!). Non tutto [quasi nulla] vi sara' chiaro in questa introduzione ma non ha importanza. INTRODUZIONE : Prima di tutto cerchiamo di capire cos'e' la programmazione orientata agli oggetti, ma prima ancora cos'e' la programmazione. Premetto che quello di cui parlero' e' alquanto vasto, sara' semplice perdere il filo del discorso ma cerchero' di essere il piu preciso possibile...e si va! Un linguaggio di programmazione che cos'è? Un linguaggio! Come l'italiano e l'inglese, non ha differenza. La sola differenza e che e' una macchina a doverlo capire, quindi il linguaggio deve essere privo di ogni possibile ambiguita'. Un linguaggio di programmazione ha la sua semantica e la sua sintassi; la sintassi equivale alla grammatica nei linguaggi "umani", la semantica al suo significato. Il linguaggio di programmazione piu' vicino alla macchina e' l'assembly (n.b. che non ho scritto assembler). Una istruzione assembly viene tradotta immediatamente in codice macchina (0 e 1 per capirci, insomma in logica digitale) da un software chiamato assembler. La potenza di questo linguaggio e' indiscussa,ma i tempi di stesura di codice sono imbarazzanti: sono stati cosi' creati linguaggi di programmazione di piu' "alto livello", dove il linguaggio e' stato avvicinato al modo di ragionare umano, ma il risultato e' identico, poiche' ogni istruzione di alto livello (ad esempio di linguaggio c) viene tradotta in linguaggio assembly prima di essere creato un eseguibile dell'applicazione. Questi linguaggi di programmazione che stanno sopra l'assembly sono solitamente i linguaggi
procedurali (che poi vedremo). Un sorgente scritto in c, che e' di tipo procedurale, viene quindi tradotto da un "compilatore". Quindi non tutti i compilatori sono uguali, in quanto ognuno traduce in maniera differente il codice di alto livello: tutti daranno lo stesso risultato ma prestazioni differenti. quindi per ora possiamo immaginate tale modello di astrazione ----------------------- linguaggi procedurali ----------------------- assembly ----------------------- hardware ----------------------- I linguaggi procedurali sono ad esempio c e pascal. Un programma nasce dall'esigenza di risolvere un problema, avendo un approccio di tipo procedurale, questo problema viene suddiviso in problemi piu' piccoli, dove ognuno di questi problemi viene risolto da una procedura. Ora aggiungiamo il livello di astrazione al nostro modello ---------------------- object oriented ---------------------- linguaggi procedurali ---------------------- assembly ---------------------- hardware ---------------------- Come si nota dal disegno il nuovo livello di astrazione si allontana dall'hard-ware, ma si avvicina sempre di piu' al modo di ragionare umano. I linguaggi di programmazione oo (object oriented -> orientati agli oggetti) cercano di riprodurre la realta' tramite
oggetti. Immaginiamo di voler rappresentare eclip in codice java [eclip è un mio amico alquanto suonato ;) ]. public class Persona { \*attributi*\ int altezza; String coloreocchi; \*metodi*\ salta() { System.out.println ("sto saltando"); In questa maniera ho descritto le caratteristiche di una generica persona, questa descrizione viene chiamata classe. Posso quindi creare un oggetto di nome eclip che ha queste caratteristiche cosi': Persona Eclip = new Persona() non provatelo che il codice non funzionera' e in seguito capirete il perche'. Immagino che dal codice abbiate capito poco o niente, ma e' giusto cosi', dovete piu' che altro catturarne la struttura e la logica... Che cos'e' una classe? codice che descrive degli oggetti. Una classe si divide in metodi e attributi. Gli attributi sono i dati che avra' l'oggetto creato da quella classe, i metodi sono le "azioni" che l'oggetto creato da quella classe puo' fare. Creiamo un eclip che funziona e capiamolo passo passo (eheheh): public class Persona { \\ attributi String nome; int altezza; \\questo metodo viene eseguito quando viene eseguita la classe persona public static void main (String args[]){ \\creiamo l'oggetto eclip che avra' le caratteristiche della classe persone (metodi e attributi) Persona eclip = new Persona(); //poi vedremo in dettaglio che vuol dire
\\questo metodo viene eseguito quando viene istanziato un oggetto della classe persona e viene chiamato costruttore public Persona() { name = " eclip"; altezza = 180; ve lo trascrivo senza commenti public class Persona { String nome; int altezza; public static void main (String args[]){ Persona eclip = new Persona(); public Persona() { name = " eclip"; altezza = 180; Cosa ne facciamo di questo codice? Non fa parte dell'introduzione. Su questo ci soffermeremo a lungo, ma prima abbiamo bisogno delle conoscenze base. Passiamo alla pratica installando tutto il necessario per eseguire codice java. E se non avete capito una mazza non preoccupatevi...e' del tutto normale, capirete più avanti! seconda puntata --------------- INSTALLAZIONE DELL'OCCORRENTE: Prima di tutto installiamo la virtual machine,poi vedremo a che serve.qui verso la fine e' spiegato bene http://www.sal.disco.unimib.it/programmazione/download/lezioni/2005-10-05_esercitazione_01.p df vi dira' un link per un download non funzionante voi usate questo http://java.sun.com/j2se/1.5.0/install.html e scegliete quello per la vostra architettura. Se sul materiale che vi ho linkato non vi sembra spiegata bene la procedura di installazione installazione, potete cercare materiale da google...e ne troverete aiosa.
Nella slyde e spiegata l'installazione per windows. Per linux cercate sulla documentazione della vostra distro ( per ubuntu http://wiki.ubuntuit.org/installazionejava ) Una volta installato avrete a disposizione due nuovi comandi che ci interessano. java javac noi scriveremo i sorgenti in un file con estensione java,ad esempio Spiderz.java, lo compiliamo cosi': javac Spiderz.java ed otteniamo un file Spiderz.class; scriviamo : java Spiderz e il nostro programma viene eseguito. usate questo sorgente per provare: public class Spiderz { public static void main (String args[]){ System.out.println ("welkome to spiderz forum "); ------->>>>>>>>>NOTA BENE : IL FILE.JAVA DEVE AVERE LO STESSO NOME DELLA CLASSE PUBBLICA, IN QUESTO CASO IL NOME DEL FILE SARA' Spiderz.java e occhio alle maiuscole e minuscole! <<<<<<----------- Che cosa fa lo scoprimremo piu' avanti, per il momento scriveremo i nostri programmi solamente nel main ovvero public class Spiderz { public static void main (String args[]){ //qui metterete il vostro codice tutto quello che imparerete + o - vale anche per c, per questo ho preferito fare un mini tutorial su java. La vera potenza del linguaggio java sta nel poter essere eseguito su tutte le piattaforme, senza alcuna modifica di codice. Questo e' dovuto alla virtual machine, un software che emula una macchina, macchina che si occupa di interpretare il bytecode.
Il bytecode e' il risultato di una compilazione di un sorgente java[ il.class]. La virtual machine deve essere installata per poter eseguire un programma java (piu' precisamente il bytecode). immaginate questo: Test.java --> compilatore---> Test.class -->virtual machine-->nostro computer quindi io scrivo il mio programma in un file.java, lo compilo ed ottengo il.class, faccio eseguire alla virtual machine il.class ed ecco la mia apllicazione. Esistera' una virtual machine e un compilatore per ogni architettura cosi' gli stessi programmi possono essere eseguiti su differenti architetture, se fornite di virtual machine. Detto questo sappiamo quanto basta per iniziare a programmare, ad eccezzione di un buon editor che ci facilita' la stesura di un programma. Per chi usa windows consiglio jcreator (freeware), per i linuxiani gedit o kwrite vanno già benissimo! Quando sarete piu' esperti un ottimo IDE [ambiente di sviluppo integrato] e' sicuramente eclipse. terza puntata --------------- In realta' noi non useremo le potenzialita' di java per un po' perche' abbiamo bisogno prima di alcune nozioni. I commenti in java si segnano con // per commentare una riga intera oppure /*commento*/. Noi come gia' detto scriveremo i programmi nel main public class NomeClasse{ public static void main (String args[]){ /*qui scriverete il vostro programma*/ il file su cui salverete il source avra' lo stesso nome della classe con il nome public: per ora non ponetevi il problema in quanto useremo solo una classe che segneremo sempre pubblica. Per eseguire l'esempio daremo: javac NomeClasse.java java NomeClasse e naturalmente il programma non fara' nulla. finito questo breve ripassino passiamo alle variabili, cosa sono e come si usano. Una variabile e' un contenitori di dati, ad esempio se voglio fare una somma, avro' bisogno di tre variabili, due che mi contengano i due operandi e uno per il risultato.
Esistono vari tipi di variabili a seconda del dato che devono contenere (char,numeri interi o con virgola,etc). Per dichiarare una variabile : tipo nomevariabile; dove al posto di nomevariabile metteremo un nome che renda l'idea di che uso ne faremo della variabile, e per tipo il tipo della variabile: i tipi che per ora ci interessano possono essere.. -tipo boolean puo contenere il valore true o false -tipo int per i numeri interi -tipo float per numeri con la virgola, con un solo numero dopo la virgola (singola precisione) -tipo char per i caratteri Per creare una variabile, se ad esempio voglio fare la somma tra un numero contenuto nella variabile a e un numero contenuto nella variabile b, e mettere il risulato nella variabile c: //nota che ogni istruzione e seguita da un punto e virgola //creo la variabile di tipo intero a int a; //gli assegno il valore 2 a = 2; //creo la variabile b int b; //gli assegno il valore 5 b = 5; //creo la variabile c int c; //assegno alla variabile c il risultato di a + b c = a + b; lo trascrivo senza commenti int a; a = 2; int b; b = 5; int c; c = a + b; quindi abbiamo fatto per ogni variabile una dichiarazione ed un assegnamento, in due istruzioni ma potevamo farlo in un unica istruzione cosi':
//creo e inizializzo con il valore 2 la variabile a int a = 2; int b = 5; int c = a + b; mettiamo tutto nel codice che vi ho dato prima per darlo in pasto al compilatore e ne uscira' questo codice: ----------------------------------------------------------------------------------------------------------------------- public class NomeClasse{ public static void main (String args[]){ /*qui scriverete il vostro programma*/ //creo e inizializzo con il valore 2 la variabile a int a = 2; int b= 5; int c = a + b; ------------------------------------------------------------------------------------------------------------------------ copiatelo e incollatelo in un file di nome "NomeClasse.java" ed eseguitelo.poi compilatelo: javac NomeClasse.java ed eseguitelo: java NomeClasse a questo punto il programma non fa nulla. Ovvero fa le somme che vi ha detto ma nessuno gli ha detto di stamparlo a monitor. Per stampate a monitor bisogna usare questa istruzione (per ora prendetela cosi') che e' System.out.println(/*qui mettete la variabile da visualizzare*/); quindi applichiamo una modifichina al source : ----------------------------------------------------------------------------------------------------------------------- public class NomeClasse{ public static void main (String args[]){ int a = 2; int b=5 int c = a +b; //stampo a monitor il contenuto della variabile c System.out.println(c); --------------------------------------------------------------------------------------------------------------------- eseguite ed otterrete come output il numero 7 [c = a+b = 2 + 5 =7] possiamo anche fare una cosa del genere: ----------------------------------------------------------------------------------------------------------------------- public class NomeClasse{ public static void main (String args[]){ int a = 2;
int b = 5; //stampo a monitor il risultato di a + b System.out.println(a+b); --------------------------------------------------------------------------------------------------------------------- Passiamo ai char... i char vengono assegnati cosi': char c; c = 'a'; ovvero il carattere da assegnare si mette tra apici. per stamparla a monitor: System.out.println(c); e verra' visualizzato il carattere a. Il carattere = viene detto operatore di assegnamento e differisce da scrivere == che viene usato per controllare una condizione, non per "assegnare"; Gia' che parliamo di condizioni facciamo le if. ad esempio voglio stampare a monitor la variabile c solo se e' maggiore di 0, utilizzo la parola chiave if: ecco qui il codice da mettere all'interno del metodo main: int c = 5; if (c>0) System.out.println(c); nella seconda riga viene verificata se e' vera la condizione tra parentesi, se lo e' si passa all' istruzione in terza riga, altrimenti si passa direttamente alla quarta riga se c'e'. quindi se avessi scritto cosi' int c = -2; if (c>0) System.out.println(c); System.out.println(c); avrebbe fato comunque la stessa perche non essendo vera la condizione tra parentesi sarebbe passata alla quarta riga che cmq fa la stessa cosa della terza. L'if permette di eseguire piu' di un istruzione se la sua condizione e' verificata, o di saltarle se non e' verificata, raggruppando le istruzioni tra parentesi graffe, ovvero cosi'; if(/*condizione*/) {
/*istruzione1*/; /*istruzione2*/; /*istruzione3*/; spero che le cose siano chiare, non sono difficili ma un po' meno semplici da spiegare, soprattuto con java che bisogna partire con numerosi "e' cosi' poi capirai perche'!". Per eventuali errori o consigli, contattatemi.. ;) quarta puntata -------------- FACCIAMO UNA CALCOLATRICE CHE FACCIA SOLO SOMMA O DIFFERENZA: Prima di tutto acquisiremo i due operandi, e poi chiederemo all'utente che tipo di operazione fare, digitando s per la somma e d per la differenza. Per ora useremo la classe SavitchIn (se non avete il concetto di classe per ora pensatela come una libreria) per acquisire dati da tastiera. Per poter utilizzare questa libreria bisogna compilare il sorgente SavitchIn.java[che e' presente nei download di www.erroredigitale.tk] e mettere il file SavitchIn.class nella dir del programma che stiamo creando. Noi useremo queste "istruzioni" (che in realta' sono le "funzioni" nel c e i "metodi" in java, comunque vedremo dopo, per ora e' un argomento troppo avanzato). SavitchIn.readInt() SavitchIn.readNonwhiteChar() La prima serve per acquisire interi, e restituisce un intero che noi assegneremo ad una variabile: esempio: int a = SavitchIn.readInt(); cosi' il sistema attende che l'utente immetta un numero per poi assegnarlo alla variabile a. Il medesimo funzionamento lo ha il secondo metodo della classe SavitchIn, solo che preleva un carattere. Si potrebbe iniziare a fare un osservazione (piccola piccola) di come abbiamo avuto accesso a
quelle "istruzioni" (che in realta' sono metodi). Abbiamo scritto il nome della classe, un punto, e poi il nome del metodo. Come vedremo ha lo stesso significato per: System.out.println(); Ora la comprensione del programma che segue dovrebbe essere semplice... //creiamo le variabili int operando1; int operando2; int risultato; char op; //acquisiamo il primo operando System.out.println("immettere primo operando"); operando1 = SavitchIn.readInt(); //il secondo System.out.println("immettere secondo operando"); operando2 = SavitchIn.readInt(); //chiediamo all'utente se fare una somma o differenza System.out.println("digitare s per la somma, d per la differenza"); op = SavitchIn.readNonwhiteChar(); //guardiamo se op vale s, se si facciamo la somma if (op=='s') /*ricordate che le char vanno tra apici*/ { risultato = operando1 + operando2; System.out.println (risultato); if (op=='d') /*ricordate che le char vanno tra apici*/ { risultato = operando1 - operando2; System.out.println (risultato); Tutta questa porkeria la mettiamo nel main e compiliamo come al solito... ------------------------------------------------------------------------------------------------------------ public class test { public static void main (String args[]){ //creiamo le variabili int operando1; int operando2; int risultato;
char op; //acquisiamo il primo operando System.out.println("immettere primo operando"); operando1 = SavitchIn.readInt(); //il secondo System.out.println("immettere secondo operando"); operando2 = SavitchIn.readInt(); //chiediamo all'utente se fare una somma o differenza System.out.println("digitare s per la somma, d per la differenza"); op = SavitchIn.readNonwhiteChar(); //guardiamo se op vale s, se si facciamo la somma if (op=='s') /*ricordate che le char vanno tra apici*/ { risultato = operando1 + operando2; System.out.println (risultato); if (op=='d') /*ricordate che le char vanno tra apici*/ { risultato = operando1 - operando2; System.out.println (risultato); ----------------------------------------------------------------------------------------------------------------------- Osservazioni: Nel file SavitchIn.java potete notare che ogni metodo e' ben documentato nel sorgente. Noi abbiamo utilizzato solo due metodi, e ne useremo pochi altri in seguito. Vedremo in seguito che si poteva acquisire un input da tastiera in altri modi, senza ricorrere a librerie esterne. quinta puntata -------------- I booleani Vediamo piu' in dettaglio quali sono le "cose" che si possone inserire tra le parentesi dell'if. Possiamo inserire qualsiasi "cosa" che restituisca un boolean, ovvero "true" o "false". Se mi chiedo se "a>b" sara' true o false. potrei scrivere : booelan c = true; int a = 2;
int b = 1; c = a < b; System.out.println(c); e verra' stampato a monitor false, in quanto c varra' false, in quanto a non e' minore di b. Esistono degli operatori per legare piu' operazioni logiche, e sono & operatore and operatore or se suppongo a,b,c variabili booleane e scrivo: c = a & b c varra' true solo se, sia a che b, sono true(detto and logico). c = a b c varra' true se,a oppure b e' true. Naturalmente si possono legare tra di loro e l'operatore and ha la priorita'. Se io scrivo: if (true){ istruzion1; l'istruzione1 verra eseguita sempre. supponiamo che io voglia stampare un numero se compreso tra 3 a 10 questo sara' il blocco rispettivo all if if ((numero >=3) & (numero <=10)) { System.out.println(numero); Il maggiore e' uno degli operatori relazionali disponibili. Vi e' anche == (uguale) e!= (diverso). Per una lista completa cercate su google. sesta puntata ------------- Il costrutto while e simile all'if, la differenza (notevole) e che il suo corpo (le istruzioni tra le graffe)
viene eseguito a ciclo finche la condizione non diventa false. se scrivo while (true){ System.out.printl("phoby"); Avrete il mio nome che invade il vostro schermo, insomma un ciclo infinito. Quindi e' scontato che nel corpo del while devono esserci istruzioni che vadano a modificare la condizione tra parentesi. Se scrivo int a = 0 while (a<2){ System.out.printl(a); a =a + 1; System.out.printl("sei uscito dal while"); Viene creata la variabile a e viene inizializzata a 0. Siccome a e' minore di 2 viene eseguito il corpo tra le graffe. finito un ciclo viene rieseguito il controllo della condizione. Il ciclo si ripete finche' la condizione non diventa' false. Quindi l'output del codice di sopra sara': 0 1 sei uscito dal while ex claro? come direbbe bakunin... settima puntata --------------- Il for e' un potenziamento del while, ma fanno la stessa e identica cosa.
facciamo un esempio con while int a = 0 while (a <3){ System.out.println(a); a = a + 1; tradotto in un for for (int a = 0;a <3;a = a + 1){ System.out.println(a); quindi il for continua ad eseguire il suo corpo (il contenuto tra le graffe) fino a ke la condizione espressa nel secondo campo [tra le tonde] ritorna true. L'istruzione che serve a cambiare tale condizione per uscire dal ciclo viene messa nel terzo campo [viene eseguita alla fine di ogni ciclo]. Nel primo campo viene inzializzata la variabile che fara' da "contatore". Attenzione che alla chiusura del for tutte le variabili dichiarate al suo interno verranno perse. Quindi utilizzando il while la variabile a non verra persa in quanto e' dichiarata al suo esterno. Se voglio mantenere la variabile a anche uscito dal for: int a; for (a = 0;a <3;a = a + 1){ System.out.println(a); Nel primo campo posso anche fare piu' assegnamenti, anche piu' di una dichiarazione di variabile ma dello stesso tipo. Nel secondo campo posso mettere qualsiasi espressione booleana (posso legare quindi piu' condizioni con & oppure ). Nel terzo campo posso rifilare quante operazioni voglio. Questo esempio dovrebbe rendere l'idea, se io scrivo for (int i = 0; i <10; System.out.println(i), i = i +1){ questo for sembra vuoto, ma siccome le istruzioni del terzo campo sono sempre eseguite se si entra nel ciclo, quel for equivale a questo for (int i = 0; i <10;i = i +1){ System.out.println(i);
che equivale anche a questo: for (int i = 0; i <10;;){ System.out.println(i); i = i +1; che equivale a questo while: int i = 0; while (i <10){ System.out.println(i); i = i +1; Un po' di esempi per vedere se avete capito... ------------------------------------------------------------------ for(int a = 0; a < 2;;){ System.out.println(a); Questo e' un ciclo infinito in quanto nessuna istruzione modifica a...quindi la condizione sara' sempre vera... ------------------------------------------------------------------ for(int a = 0; a > 2; a++;){ System.out.println(a); Questo ciclo non verra' mai eseguito in quanto la condizione di ingresso non sarà mai vera... [a++ equivale a fare a = a + 1] ------------------------------------------------------------------- for(int a = 0; a < 2; a++;){ System.out.println(a); System.out.println(a); Questo codice non compila in quanto la variabile a viene distrutta all'uscita dal for e non esiste quindi per l'istruzione di stampa. il codice per compilarlo va corretto così int a; for(a=0; a < 2;;){ System.out.println(a); -------------------------------------------------------------------- Se non avete capito, non proseguite in quanto questi concetti sono fondamentali, in tal caso puo'
'essere che io mi sia spiegato male, quindi vi consiglio di consultare altre guide prima di proseguire. ;) ottava puntata -------------- E da molto che non continuo la guida, e ho impiegato mezz'oretta a correggere le boiate che ho scritto, che per fortuna mi sono state segnalate, ora dovrebbe essere tutto giusto...mi scuso...mi inkino a voi...skusate!! ;) Torniamo seri...[certo 8) ] Fino a questo punto abbiamo utilizzato solo il main, che e' un metodo che deve essere presente nella classe che viene eseguita per prima (noi per ora ne abbiamo usata max una). Per ora utilizzeremo java in maniera erronea, ovvero come se fosse un linguaggio procedurale, ma e' l'unica maniera per poter proseguire nell'apprendimento. Proviamo a creare noi un nostro metodo, il metodo somma, io butto giu' il codice poi lo vediamo passo passo. public class Lalala { public static void main (String args[]){ int operando1,operando2,risultato; operando1 = 1; operando2 = 3; risultato = Lalala.somma(operando1,operando2); System.out.println(risultato); public static int somma(int a,int b){ int c = a + b ; return c; in questa parte di codice viene creato questo metodo. public static int somma(int a,int b){ int c = a + b ; return c; e in questa parte lo abbiamo usato risultato = Lalala.somma(operando1,operando2);
Partiamo dalla creazione ed e' importante studiare la prima riga: public static int somma(int a,int b) le prime due parole per ora le prendete cosi' e le metterete sempre, quindi passiamo ad analizzare le successive int somma(int a,int b) tra le parentesi viene descritto dove andranno a finire (in che variabili e di che tipo) i valori che io passo all'interno del mio metodo. La prima parola indica di che tipo e' il valore ritornato dal metodo. (essendo il risultato della somma tra interi e' un int); quando scrivo somma(3,2) dove somma e il nome del metodo, assegno alla variabile a il valore 3 ed alla b il valore 2. Nel corpo del metodo viene svolta la somma e la parola return indica cosa deve ritornare il metodo, che come si legge dal codice ritorna la variabile c. risultato = Lalala.somma(operando1,operando2); Come si legge da questa riga il valore ritornato della funzione viene assegnato alla variabile "risultato". Per accedere al metodo ho usato la notazione col punto, ma essendo il metodo interno alla classe in cui lo uso, potevo scrivere solamente risultato = somma(operando1,operando2); senza specificare la classe in cui si trova il metodo. Creiamo un metodo che...che...non ho idee...facciamo che esegua istruzioni a muzzo tipo un po' di print. public static void nonfaccionulladisensato (){ System.out.println("il fumo uccide? si ma non sempre, l'ignoranza uccide continuamente!"); Come notate le parentesi sono vuote in quanto non necessita di parametri in input e il tipo di ritorno e' void, ovvero non torna nulla. Per usarlo scrivete nel vostro main nonfacciofaccionulladisensato(); e verra' eseguita la print.
All'interno di un metodo possono essere richiamati anche altri metodi. quindi per ora (lo faremo meglio nelle prox lezioni) stiamo usando java in maniera procedurale. Prima di utilizzarlo seriamente dobbiamo prendere grossa dimestichezza con i metodi e dobbiamo ancora vedere le stringhe...[ke noia!!...diventa molto più interessante arrivati alle socket!] Prima di chiudere la puntata facciamo una calcolatrice che fa somma e differenza (uguale a quella scorsa) solo che utilizza metodi fatti da noi: public class test { public static void main (String args[]){ //creiamo le variabili int operando1; int operando2; int risultato; char op; //acquisiamo il primo operando System.out.println("immettere primo operando"); operando1 = SavitchIn.readInt(); //acquisiamo il secondo operando System.out.println("immettere secondo operando"); operando2 = SavitchIn.readInt(); //chiediamo all'utente se fare una somma o differenza System.out.println("digitare s per la somma, d per la differenza"); op = SavitchIn.readNonwhiteChar(); //guardiamo se op vale s, se si facciamo la somma if (op=='s') /*ricordate che le char vanno tra apici*/ { risultato = somma(operando1,operando2); System.out.println (risultato); if (op=='d') /*ricordate che le char vanno tra apici*/ { risultato = diff(operando1,operando2); System.out.println (risultato); public static int somma(int a, int b){ int c = a + b; return c; public static int diff(int a, int b){ int c = a - b;
return c; Questa la lascio analizare a voi...se non la capite, non avete capito granche', quindi tornerei indietro, o cercherei su altre guide... Per info date un occhio all'home page del mio sito [www.erroredigitale.tk]. nona puntata ------------ Ora un altro argomento estremamente importante...le stringhe! Una stringa e' un tipo di dato che permette di contenere una sequenza di caratteri. Per ora alcune cose non ve le diro', ma verranno dette quando useremo gli oggetti. Se volessi salvare il mio nome in un char...non potrei in quanto contiene solo un carattere, potrei usare un array di char, ma noi gli array non gli abbiamo trattati, e cmq sono scomodi, ma bensi usiamo le stringhe, così: String mionome = "phoby"; System.out.println(mionome); verra' stampato a monitor il mio nome quindi la creazione di una stringa ha la seguente sintassi: String nomevariabile = "testo";... ATTENZIONE String va' scritto con la S maiuscola se no non va!!... Ogni carattere inserito nella stringa ha una sua posizione Le posizioni partono da 0 fino alla fine della stringa...dall'esempio [String nomevariabile = "testo";]così: caratteri t e s t o posizioni 0 1 2 3 4 quindi possiamo vedere la stringa come una sequenza di char, e accedere ad una singola posizione tramite il metodo charat()...così [upponiamo mi interessi la lettera in posizione 3 che e' un char con valore 't']: String prova = "testo"; char lettera = prova.charat(3); Per ottenere la lunghezza di una stringa (che equivale all'ultima posizione +1), si puo' usare il metodo length()..così: int lunghezza = prova.length();
Per stampare, una lettera alla volta di una stringa, andando a capo dopo ogni lettera, questo e' il codice... String prova = "peppino" for(int i = 0; i < prova.length(); i++){ System.out.println(prova.charAt(i)); l'output sara' p e p p i n o SPEZZIAMO LE STRINGHE Supponiamo questa stringa String test = "ciao ok" carattere c i a o o k posizione 0 1 2 3 4 5 6 Mettiamo caso che mi interessino le posizioni dalla 3 alla fine della stringa uso questo metodo String ciao =""; ciao = test.substring(3); System.out.println(ciao); E verra' stampato a monitor: o ok Se io volessi una stringa da 2 a 3 farei così: ciao = test.substring(2,1); dove il primo parametro indica dove iniziare il taglio[posizione 2], e il secondo di quanto avanzare per chiudere il taglio [1]. Per confrontare una stringa con un altra stringa [per vedere se sono uguali] si usa il metodo equals che ritorna un boolean, true nel caso siano uguali...esempio: ---------------------------- String stringa1 = "prova"; String stringa2 = "prova";
boolean a = stringa1.equals(stringa2); if(a){ System.out.println("sono uguali"); ------------------------- potevo anche scriverlo così: ------------------------- if(stringa1.equals(stringa2)){ System.out.println("sono uguali"); ------------------------- oppure così ------------------------- if(stringa2.equals(stringa1)){ System.out.println("sono uguali"); ------------------------- perfezionamo il programma così ---------------------------- if(stringa1.equals(stringa2)){ System.out.println("sono uguali"); else{ System.out.println("sono diverse"); ---------------------------- L'else serve a far eseguire le istruzioni in esso contenute nel caso in cui l'istruzione if che lo precede non sia stato eseguito, quindi leggendo il codice in maniera naturale: SE STRINGA1 E' UGUALE A STRINGA2, STAMPA A MONITOR "SONO UGUALI" ALTRIMENTI STAMPA A MONITOR "SONO DIVERSE" Possiamo anche usare l'operatore "!" che inverte la condizione booleana, ovvero se scrivo boolean a = false; boolean b =!a; b varra' il contrario di a, ovvero true... quindi il codice con l'else equivale a questo ------------------------------------- if(stringa1.equals(stringa2)){ System.out.println("sono uguali"); if(!(stringa1.equals(stringa2))){ System.out.println("sono diverse");