introduzione alla programmazione java

Introduzione alla programmazione Java

Di Massimiliano Brolli

Premessa .................................................................................................................................................. 3

Prerequisiti ............................................................................................................................................... 4

L’interprete, la virtual Machine di Java ................................................................................................... 5

L’ambiente per sviluppare in Java ........................................................................................................... 5

Scrivere codice in Java............................................................................................................................. 7

Il concetto di classe .............................................................................................................................. 7

I Metodi ................................................................................................................................................ 8

Il metodo costruttore .......................................................................................................................... 11

I Pakage .................................................................................................................................................. 14

Le costanti e le variabili ......................................................................................................................... 16

IL casting ........................................................................................................................................... 18

Scopo delle variabili .......................................................................................................................... 19

Le proprietà di classe ......................................................................................................................... 21

Le Enumaration .................................................................................................................................. 21

Array o Vettori ....................................................................................................................................... 23

I Cicli ..................................................................................................................................................... 26

Il ciclo For .......................................................................................................................................... 26

Il ciclo While...................................................................................................................................... 26

Gli operatori ........................................................................................................................................... 28

Gli operatori matematici .................................................................................................................... 28

Gli operatori di espressione ............................................................................................................... 28

Le condizioni ..................................................................................................................................... 29

L’accesso ai file ..................................................................................................................................... 31

Leggere un file ................................................................................................................................... 31

Scrivere un file ................................................................................................................................... 32

Aprire un file già esistente in sovrascrittura ...................................................................................... 32

Leggere i file contenuti in una directory ............................................................................................ 32

Le eccezioni in Java ............................................................................................................................... 33

Scrivere bene il codice ........................................................................................................................... 35

Un’attività molto delicata .................................................................................................................. 36

Occorre commentare bene i programmi ............................................................................................ 36

L’indentazione del codice .................................................................................................................. 38

Regole da rispettare quando scriviamo codice ................................................................................... 38

Premessa

I linguaggi di programmazione di alto livello introducono apposite strutture per la memorizzazione dei dati ed inoltre permettono al programmatore di assegnare un nome ad ogni locazione di memoria effettivamente utilizzata nel corpo del programma per la memorizzazione dei dati. Questo meccanismo di memorizzazione dei dati a basso livello, rende più facile riferirsi ai dati stessi come nel caso di C, C++, piuttosto che specificare esplicitamente i relativi indirizzi di memoria, compito questo che viene totalmente demandato al linguaggio di programmazione stesso (cioè al compilatore o all’interprete). Come avviene ad esempio in Java o in C#. Inizialmente nato come un progetto per implementare codici di programmazione dentro apparecchi elettronici di comune utilizzo casalingo, originariamente chiamato OAK da James Gosling, oggi Java è il più popolare linguaggio utilizzato nella rete internet e in tutte le piattaforme che ne abbiano bisogno, è un linguaggio

• Class-Based (basato su Classi) • Object Oriented (orientato agli oggetti)

specificamente disegnato per implementare qualsiasi tipo di dipendenze necessarie.

Nell'hardware abbiamo continui aggiornamenti, sempre maggiori sono le novità e le nuove tecnologie, il mondo informatico si divide in tante piattaforme software dedicate o meno: sempre più spesso le aziende preferiscono utilizzare macchine e programmi dedicati, come il Mac, le Silicon Graphic, Linux, Solaris, Windows, Ubuntu ecc.

Quindi come possiamo noi poveri programmatori sviluppare soluzioni che possono funzionare su ognuna di queste differenti piatatforme, server o workstation? Sviluppiamo con Java!

Deriva da uno dei linguaggi più potenti al mondo, il linguaggio C++, la differenza

sostanziale è che il C e C++ sono spesso utilizzati come soluzioni di ricerca, Java è più raccomandato per la produzione. Come sintassi è molto semplice da comprendere per la maggior parte degli sviluppatori che già conoscono C o C++ o linguaggi da esso derivati (Bash, PHP, Perl).

La novità di Java è proprio quella di poter girare su qualsiasi piattaforma, in effetti è detto anche linguaggio Multipiattaforma ovvero offre la possibilità ai programmatori di sviluppare il proprio programma una sola volta e di eseguirlo in numerose piattaforme senza dover riscrivere nessuna riga di codice.

Prerequisiti Per procedere alla lettura di questo documento occorre aver letto le seguenti dispense :

• Introduzione agli algoritmi. • La scelta tra Microsoft.NET & Java • Predisposizione Virtual Machine di base • Predisposizione Virtual Machine per l'ambiente di sviluppo Java

L’interprete, la virtual Machine di Java Il segreto della Multipiattaforma Java è tutto racchiuso nella Java Virtual Machine (JVM).

La JVM è un interprete, un piccolo software che ha le sue versioni per quasi tutte le piattaforme conosciute, Windows, Linux, Mac, dispositivi portatili, cellulari, palmari ecc... non interessa più al programmatore sviluppare la propria soluzione seguendo le regole del sistema operativo e le librerie dell'hardware utilizzato. Naturalmente ciò consente di sviluppare codice di programmi anche per dispositivi differenti dai personal computer o dai server

Una appropriata Java Virtual Machine si può inserire molto facilmente in un cellulare, in un forno a microonde o in un frigorifero dando la possibilità di sviluppare codice che interagisca con i comandi elettronici del dispositivo e programmarci un piccolo sistema operativo dedicato che automatizzi i processi.

Nato da SUN Microsystem, ottimizzato per i loro server Solaris e workstation multiprocessori Sparkle, Java risulta essere la soluzione per tanti sviluppatori che hanno necessità di un sistema multipiattaforma di largo uso.

Java stesso si divide essenzialmente in tre piattaforme differenti, utili a seconda dell'uso e del tipo di progetto da sviluppare:

• Java 2 Standard Edition (J2SE) - E' la piattaforma più utilizzata, contiene il Java Developer Kit che serve per compilare i codici sorgenti Java.

• Java 2 Enterprise Edition (J2EE) - Una piattaforma di sviluppo interamente dedicata a soluzioni Client Server, utilizza un Application Server che memorizza gli oggetti, i database ed i componenti nel server, che saranno poi utilizzati dallo sviluppatore Java Client.

• Java 2 Micro Edition (J2ME) - La piattaforma di sviluppo per i dispositivi portabili, come cellulari o palmari.

L’ambiente per sviluppare in Java Come visto in precedenza, per utilizzare Java occorre installare un interprete relativo al sistema operativo sul quale stiamo sviluppando.

E’ consigliabile scaricare dal sito Oracle l’ultima versione della J2SE ed installarla nella macchina sulla quale si andrà a sviluppare. Ovviamente avendo già creato la Virtual Machine non andremo a dettagliare passo passo la procedura di installazione. Come tutti i linguaggi di programmazione che Java dispone di molteplici RAD (Rapid Application Development) tramite i quali è possibile disporre di un unico ambiente finalizzato nella scrittura del codice, condivisione dei sorgenti e testing. Nel nostro caso utilizzermo Eclipse della IBM, software gratuito che raccogli numerose funzionalità essendo incentrato in una logica di Plug-In, anch’esso installato precedentemente sulla Virtual Machine.

Tenete in considerazione che Eclipse è uno strumento modulare progettato sulla logica dei Plug-In, pertanto esistono una miriade di software che possono essere aggiunti e fornire infinite funzionalità al prodotto.

Scrivere codice in Java Di seguito vedremo la istruzioni fondamentali in Java per scrivere codice che devono essere conosciute dallo sviluppatore per poter scrivere i propri programmi.

Il concetto di classe

Una classe è un programma. E’ un tipo di dato strutturato definito per rappresentare un'entità complessa quale può essere ad esempio un conto bancario, un prodotto commerciale, una persona. Tutto questo può sembrare difficile da comprendere venendo dalla programmazione strutturata o da altri linguaggi quali il COBOL, il C o il fortran, ma vedrete che mano a mano che andremo avanti sarà molto semplice ragionare a classi anche nel quotidiano. Sicuramente il corso successivo sulla programazione Object Oriented ci chiarirà meglio le idee. Ora cerchiamo di definire una classe che rappresenti un impiegato di una società. Innanzitutto dobbiamo chiederci quali informazioni rappresentino un impiegato. public class Impiegato {

private String nome;

private String cognome;

private int annoNascita;

private int stipendio;

private String posizione;

final int stipendioMax;

final int stipendioMin;

} La prima riga contiene la dichiarazione della classe.

• Compare la parola chiave class che indica al compilatore Java l'operazione che stiamo eseguendo.

• La classe Impiegato è definita public, cioè pubblica. • Questo vuol dire che potrà essere utilizzata o inclusa in altre classi o più in

generale in altri progetti, senza alcuna restrizione. • Le parentesi graffe ({, }) racchiudono il codice che definisce la classe • All'interno compare la dichiarazione di variabili di classe che abbiamo

considerato di nostro interesse per la definizione di un oggetto di tipo Impiegato.

• Tali variabili di classe sono il nome, cognome e posizione in azienda rappresentate da tre variabili di tipo String chiamate rispettivamente nome, cognome e posizione.

• A queste si aggiungono le informazioni riguardanti anno di nascita e stipendio, rappresentate da altre due variabili di tipo int chiamate rispettivamente annoNascita e stipendio.

• Infine compare la dichiarazione di due costanti di tipo intero che rappresentano rispettivamente lo stipendio minimo e massimo che può ricevere un impiegato e sono stipendioMin e stipendioMax. Osservate che nessuna di queste variabile è stata inizializzata in questa fase di definizione della classe.

I Metodi

Una volta definite le variabili di classe dobbiamo aggiungere una serie di funzioni, che in java vengono più propriamente chiamati metodi che operando sulle variabili di classe e descrivendo il comportamento e le operazioni che sarà possibile effettuare. I metodi che andremo ad implementare per la nostra classe Impiegato sono :

Cominciamo a scrivere il codice per la definizione dei metodi. Prima però andiamo ad analizzarne uno. private void variaStipendio (int variazione) { if (stipendio + variazione > stipendioMin) stipendio = stipendio + variazione; else stipendio = stipendioMin; if (stipendio > stipendioMax) stipendio = stipendioMax; }

La parte evidenziata in giallo viene chiamata comunemente firma La parte evidenziata in azzurro viene invece chiamata corpo del metodo. Il corpo del metodo è racchiuso tra due parentesi graffe aperta e chiusa.

Nome Metodo Descrizione

mostraNome() visualizzerà nome e cognome dell'impiegato

calcolaStipendio() restituirà un valore intero pari allo stipendio

calcolaEta(int anno) restituirà un valore intero pari l'età dell'impiegato in particolare anno

variaStipendio(int variazione) varia lo stipendio

aumentaStipendio(int aumento) incrementerà lo stipendio di una quantità pari a aumento

riduciStipendio(int riduzione) ridurrà lo stipendio di una quantità pari a riduzione

La firma del metodo contiene il nome del metodo che servirà per richiamarlo e indica se tale metodo riceverà un input e se restituirà un Output. Procediamo con la scrittura del nostro primo metodo mostraNome() public void mostraNome()

{

System.out.println(nome + " " + cognome);

}

Analizziamo la firma del metodo.

• Visibilità : Viene riportata la visibilità del metodo come public, ciò vuol dire che tale metodo sarà visibile dall’esterno.

• Input : Vengono riportate dopo il nome del metodo le parentesi tonde aperte e chiuse (), ciò vuol dire che il metodo non disporrà di nessun parametro di input.

• Output : Viene riportata la clausola void, ciò vuol dire che il metodo non restituirà alcun Output.

Il corpo della funzione è costituito semplicemente dall'istruzione System.out.println(nome + " " + cognome);

Istruzione già incontrata in precedenza, il cui scopo è visualizzare una stringa contenente il valore delle proprietà nome e cognome dell'oggetto di tipo Impiegato su cui è stato richiamato il metodo separate da uno spazio. Procediamo con la scrittura del metodo calcolaStipendio() public int calcolaStipendio ()

{

return stipendio;

}



• Input : Vengono riportate dopo il nome del metodo le parentesi tonde aperte e chiuse (), ciò vuol dire che il metodo non disporrà di nessun parametro di input.

• Output : Viene riportata la variabile int, ciò vuol dire che il metodo restituirà un valore intero. Questa dichiarazione viene rispettata in quanto nel corpo del metodo è presente l’istruzione return stipendio. stipendio è una variabile locale di tipo intero.

Procediamo con la scrittura del nostro primo metodo calcolaEta()

public int calcolaEta (int annoCorrente)

{

int eta = annoCorrente - annoNascita;

if ((eta>=16) && (eta<=90))

return eta; else

return 0;

}



• Input : Viene riportata dopo il nome del metodo la variabile intera annoCorrente, tale variabile costituirà l’input per il nostro metodo.

• Output : Viene riportata la variabile int, ciò vuol dire che il metodo restituirà un valore intero. Questa dichiarazione viene rispettata in quanto nel corpo del metodo viene restituito un intero al termine dell’elaborazione.

Inoltre nel corpo è presente un'istruzione if... then... else... Vedremo successivamente il suo utilizzo Procediamo con la scrittura del metodo variaStipendio() private void variaStipendio(int variazione)

{

if (stipendio + variazione > stipendioMin) {

stipendio = stipendio + variazione;

}else{

stipendio = stipendioMin;

}

if (stipendio > stipendioMax)

stipendio = stipendioMax;

}


• Visibilità : Viene riportata la visibilità del metodo come private, ciò vuol dire che tale metodo non sarà visibile dall’esterno ma potrò essere richiamato solo da altri metodi presenti all’interno della classe.

• Input : Viene riportata dopo il nome del metodo la variabile intera variazione, tale variabile costituirà l’input per il nostro metodo.

• Output : Viene riportata la clausola void, ciò vuol dire che il metodo non restituirà alcun Output.

Procediamo con la scrittura del metodo aumentaStipendio() e riduciStipendio() public void aumentaStipendio (int incremento){

variaStipendio (incremento);

}

public void riduciStipendio (int riduzione){

variaStipendio (riduzione*(-1));

} Analizziamo la firma del metodo.

• Visibilità : Viene riportata la visibilità dei metodi come public, ciò vuol dire che tali metodi saranno visibile dall’esterno.

• Input : Viene riportata dopo il nome dei metodi la variabile intera incremento/riduzione, tale variabile costituirà l’input per il nostro metodo.

• Output : Viene riportata la clausola Sub, ciò vuol dire che i metodi non restituiranno alcun Output.

Il due metodi sono metodi pubblici, non restituiscono alcun valore ma ne richiedono uno in input di tipo intero (int) cui viene dato il nome incremento o riduzione. Il metodo opera richiamando il metodo privato variaStipendio().

Il metodo costruttore

L'inizializzazione di un oggetto, al momento della sua creazione, avviene attraverso un metodo particolare detto costruttore. Il costruttore è un metodo che viene richiamato automaticamente ogni volta che viene creato una istanza di una determinata classe. Il costruttore per essere distinto dagli altri metodi in Java deve avere lo stesso nome della classe, quindi nel nostro caso, si deve chiamare Impiegato(). Definiamo il costruttore della classe Impiegato. public Impiegato (String nome,

String cognome,

int annoNascita,

String posizione)

{

stipendioMin = 750;

stipendioMax = 2000;

this.nome = nome;

this.cognome = cognome;

this.annoNascita = annoNascita;


this.posizione = posizione;

}

Analizziamo la firma del costruttore.

• Visibilità : Il costruttore come visibilità deve essere per forza public, ciò vuol dire che tale metodo sarà visibile dall’esterno.

• Input : Viene riportata dopo il nome del metodo una serie di variabili le quali verranno passate al metodo costruttore e serviranno per inizializzare le variabili di classe.

• Output : come avrete notato non esiste Output in quanto il costruttore riceve solamente Input e non può fornire Output.

Facciamo attenzione che all’interno del corpo del costruttore sono presenti le parole chiave this. Con this.nome si richiama la variabile di classe presente nella classe Impiegato. Questo è molto utile per poter differenziare la variabile nome pervenuta dal costruttore e non confonderla con la variabile di classe nome. Altrimenti avrei potuto scrivere questo costruttore ma ovviamente il nome delle variabili n, c e p non aiuterà il programmatore nella scrittura del codice. public void Impiegato (String n, String c, int a, String p)

{

stipendioMin = 750;


nome = n;

cognome = c;

annoNascita = a;


posizione = p;

}

Nota Bene : In altri linguaggi di programmazione oltre alla presenza del costruttore è presente il distrutture della classe.

Nel C++ questa funzione viene richiamata quando tale istanza di classe verrà cestinata, serve sostanzialmente ad effettuare le disallocazione controllata delle risorse utilizzate in precedenza dalla classe stessa.

A questo punto abbiamo decisamente completato la definizione della classe Impiegato. Riporto di seguito tutta la classe di modo da vederla con una ottica di insieme. public class Impiegato {

private String nome;

private String cognome;

private int annoNascita;

private int stipendio;

private String posizione;

final int stipendioMax;

final int stipendioMin;

public Impiegato (String nome, String cognome,

int annoNascita, String posizione)

{

stipendioMin = 750;


this.nome = nome;

this.cognome = cognome;

this.annoNascita = annoNascita;


this.posizione = posizione;

}

public void mostraNome(){

System.out.println(nome + " " + cognome);

}

public int calcolaStipendio (){

return stipendio;

}

public int calcolaEta (int annoCorrente){

int eta = annoCorrente - annoNascita;

if ((eta>=16) && (eta<=90))

return eta; else

return 0;

}

public void aumentaStipendio (int incremento){

variaStipendio (incremento);

}

public void riduciStipendio (int riduzione){

variaStipendio (riduzione*(-1));

}

private void variaStipendio (int variazione){

if (stipendio + variazione > stipendioMin)

stipendio = stipendio + variazione;

else


if (stipendio > stipendioMax)

stipendio = stipendioMax;

}

}

I Pakage Un package Java è un meccanismo per organizzare classi Java all'interno di gruppi ordinati. Questi package possono essere memorizzati in file compressi chiamati file JAR, permettendo la trasmissione di più classi in una sola volta durante la distribuzione del software. I programmatori spesso usano i package per riunire classi logicamente correlate o che forniscono dei servizi simili. I file sorgente di classi Java possono includere un'istruzione package all'inizio del file per indicare di quale package fa parte. Nei file sorgente di Java, il package a cui appartiene il file è specificato con l'istruzione package ed è la prima riga di un sorgente Java. package java.awt.event; Per usare delle classi appartenenti ad un dato Package all'interno di una classe Java è necessario includere tale package con l'istruzione import. L’asterisco ci permette di andare ad utilizzare nel corpo della classe tutte le classi contenute all’interno del package java.awt.event. import java.awt.event.*; Mentre se si importa solo ed esclusivamente la classe ActionEvent, tutte le altre non potranno essere utilizzate. import java.awt.event.ActionEvent; Per creare un riferimento in memoria della classe ActionEvent detta anche istanza si utilizza la parola new e la sintassi è la seguente. ActionEvent myEvent = new ActionEvent(); myEvent è il nome dell’istanza che verrà creata, ActionEvent invece e il tipo di classe che verrà istanziata. È anche possibile ma non pratico usare direttamente il nome intero della classe, evitando così l'istruzione import come ad esempio java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent();

Di seguito vengono riportati alcuni package fondamentali del linguaggio Java.

• java.lang — funzionalità di base del linguaggio e tipi di dato fondamentali • java.util — classi di collezione (Strutture dati) • java.io — operazioni su file • java.math — aritmetica multiprecisione • java.nio — il nuovo framework I/O per Java • java.net — operazioni di rete, socket, ricerca DNS, ... • java.security — generazione di chiavi crittografiche, sicurezza e

crittografia • java.sql — Java Database Connectivity (JDBC) per facilitare l'accesso a

database • java.awt — struttura di base per componenti GUI (Guided User

Interface) • javax.swing — struttura avanzata ed indipendente dalla piattaforma

per componenti GUI (Guided User Interface)

Le costanti e le variabili

In informatica, una variabile identifica una porzione di memoria destinata a contenere dei dati, che possono essere modificati nel corso dell'esecuzione di un programma.

Una variabile è spesso, ma non sempre, caratterizzata da un nome (inteso solitamente come una sequenza di caratteri e cifre).

Una costante è invece una posizione di memoria che mantiene lo stesso valore per tutta la durata dell'esecuzione del programma.

Nei linguaggi tipizzati, ciascuna variabile è caratterizzata da un tipo di dato, che specifica come devono essere considerati i dati rappresentati. Ad esempio, una variabile destinata a contenere il numero progressivo di un mese di una data, potrà assumere solo i valori interi da 1 a 12.

Nei linguaggi compilati, le variabili devono essere dichiarate prima di essere adoperate.

La dichiarazione consente di raggiungere due fondamentali obiettivi. Da un lato, con la dichiarazione si specifica il tipo della variabile, cosicché il compilatore è in grado di verificare eventuali errori semantici presenti all'interno di un programma sintatticamente corretto (ad esempio, non è consentito moltiplicare tra loro una variabile stringa ed una variabile intera). Dall'altro, viene valutata e definita la quantità di memoria destinata, in fase di esecuzione, a contenere i dati a cui la variabile si riferisce.

Le operazioni basilari che possono essere compiute su una variabile sono la lettura del valore in essa contenuto e la scrittura di un nuovo valore, o assegnamento. Le variabili posso essere di sette categorie:

1. Class Variable: una variabile è detta di classe quando viene dichiarata dentro la classe, quindi ha effetto solo in quella classe in cui è stata dichiarata.

2. Instance Variable: Sono quelle variabili che contengono una istanza di un oggetto.

3. Array Variable: sono quelle variabili che contengono collezioni di variabili. Troverete più avanti maggiori informazioni sugli Array.

4. Method Variable: sono delle variabili utilizzate come valori di argomenti che si passano ai Metodi o Funzioni.

5. Constructor Variable: ovvero quelle variabili che vengono passate ad un costruttore.

6. Exception-handler Parameters: Sono quelle variabili in un costrutto Try Catch che catturano il tipo di Eccezione.

7. Shared o Static Variable : Sono quelle variabili condivise da più istanze di una classe.

Per assegnare un valore ad una variabile, deve essere usato un operatore di assegnamento, alcuni esempi in Java // dichiarazione variabili

long i=50000;

int x=3;

float piGreco=3.14f;

boolean elementoPresente=false;

int x = 5;

int y = 10;

boolean risultatoBinario;

risultatoBinario = (x == y);

System.out.println(risultatoBinario); // restituisce false

risultatoBinario = (x < y);

System.out.println(risultatoBinario); // restituisce true

// esempio di oggetto String

String OggettoStringa = new String("Valore testuale ");

OggettoStringa = OggettoStringa + "dell'OggettoStringa";

System.out.println(OggettoStringa);

In realtà quello che succede è che le locazioni di memoria a cui fanno riferimento le costanti e le variabili conterranno sempre valori numerici ma questi saranno opportunamente codificati/decodificati dal programma dipendentemente dal tipo dichiarato per la costante/variabile considerata.

I valori possono essere memorizzati all’interno di variabili per mezzo di un’istruzione particolare, detta assegnamento. Tale istruzione cancella il valore precedentemente memorizzato nella variabile considerata, inserendovi un nuovo valore.

Ad esempio, nel linguaggio Java si può assegnare il valore 46 alla variabile v_a ed il valore ‘e’ alla variabile v_b con le istruzioni riportate nell’esempio seguente

v_a = 46; v_b = 'e'; In questo modo, nella locazione di memoria a cui si riferisce la variabile v_a verrà memorizzato il valore 001011102 cioè quello corrispondente al numero decimale 46, mentre nella locazione di memoria a cui si riferisce la variabile v_b verrà memorizzato il valore 011001012 cioè quello corrispondente alla codifica ASCII del carattere ‘e’, di seguito l’esempio di assegnazione in una porzione di memoria.

IL casting

E’ possibile cambiare il tipo di un valore da una variabile ad un’altra e questo viene effettuata tramite una operazione denominata Casting. Di seguito alcuni esempi da Int a String e vice versa. //cast da Integer a String

int value = 1;

String result1 = Integer.toString(value);

System.out.println("value " + result1);

//cast da String a Integer

String b = "22";

int result2 = new Integer(b);

System.out.println("value " + result2);

Esistono dei cast che vengono chiamati Impliciti o Espliciti, questo quando la variabile di input sarà contenuta nella variabile di Output come il caso di un int dentro un long o un double dentro un float. //Conversione tra tipi primitivi

int i = 100;

long l = 200;

float f = 0;

double d = 12;

l = i; // casting implicito (sicuro)

d = f; // casting implicito (sicuro)

i = (int) l; // casting esplicito

f = (float) d; // casting esplicito

Scopo delle variabili

Nei linguaggi orientati agli oggetti, le variabili di classe e i metodi hanno una loro visibilità all’interno del programma. I valori plausibili sono :

• public : la variabile sarà visibile sia all’interno che all’esterno della classe • private : la variabile sarà visibile solo all’interno della classe • protected : la variabile sarà visibile solo dalle classi appartenenti lo stesso

package o dalle classi che ne estendono le funzionalità. • static : variabile condivisa tra le varie istanze. Tale variabile se modificata

da una istanza verrà modificata su tutte le altre. • final : Indica che quella variabile una volta inizzializzata non potrà essere

più modificata. Per capire meglio il funzionamento della clausola static possiamo eseguire il programma sotto riportato. Tale programma creerà due istanze della stessa classe e una istanza andrà a modificare la variabile var1 di tipo static. Noteremo che tale modifica influenzerà anche il contenuto della seconda istanza. package varscope;

public class scope {

public static void main(String[] args) {

//Creo due istanze alla classe Test

Test t1 = new Test(1);

Test t2= new Test(2);

//Verifico il contenuto delle due variabili per entrambe le istanze

System.out.println("Istanza t1");

t1.Log();


t2.Log();

//Vado a modificare la variabile static var1 dell'istanza t1

System.out.println("Imposto var1");

t1.var1 = 25;

//Verifico il contenuto delle due variabili per entrambe le istanze

//e noto che il valore 25 è presente su entrambe le istanze


t1.Log();


t2.Log();

}

public static class Test{

static int var1;

private int var2;

public int getVar2() {

return var2;

}

public Test(int var2){

this.var2 = var2;

}

public void Log(){

System.out.println("var1 : " + var1);

System.out.println("var2 : " + var2);

}

}

} Di seguito il risultato dell’esecuzione del programma Istanza t1

var1 : 0

var2 : 1

Istanza t2

var1 : 0

var2 : 2

Imposto var1

Istanza t1

var1 : 25

var2 : 1

Istanza t2

var1 : 25

var2 : 2

Le proprietà di classe

Le proprietà di classe servono per separare l'implementazione dalla interfaccia pubblica della classe stessa e queste vengono messe a disposizione dai metodi get e set. Le variabili di classe per convenzione devono essere esposte verso l’esterno devono essere tutte veicolate dalle proprietà della classe stessa. La proprietà di una classe non è altro che un metodo che permette di modificare il valore di una data variabile di classe di modo da permettere un maggiore controllo sui dati in ingresso e sui dati in uscita. private int max = 0;

public int getMax() {

return max;

}

public void setMax(int max) {

this.max = max;

}

Ad esempio la variabile privata max non sarà accessibile dall’istanza della sua classe. Per poterla modificare andremo a creare dei metodi pubblici getMax e setMax che permetteranno di poter modificane il valore.

Il vantaggio sta nel fatto che in questo modo è possibile definire una logia di assegnazione di tale variabile come ad esempio che è possibile solo leggerla ma non inizializzarla. Per far questo potremmo tranquillamente omettere il metodo getMax.

Le Enumaration

Le enumeration sono una facilitazione nel passaggio di informazioni di inizializzazione verso un costruttore o un metodo. Per rendere meglio l’idea, se volessimo inizializzare una classe che permette di effettuare l’accesso a dei dati specificando al costruttore il tipo di database sul quale andare a connettersi avremmo le seguenti strade.

1. Passare una variabile di tipo intero (ad esempio databaseType) nella quale a secondo del valore passato verrà attivata una determinata connessione.

2. Passare una variabile di tipo stringa (ad esempio sempre databaseType) nella quale verrà riportato il valore del database al quale ci vogliamo connettere “oracle” oppure “access” ecc…

In entrambe le situazioni chi chiamerà tale costruttore dovrà conoscere le opzioni possibili in particolar modo se tale classe sarà stata compilata e quindi non visualizzabile a livello di codice. Per permettere una più facile comprensione e un veloce sviluppo sono state inventate le enumeration che permettono di associare ad un valore intero una descrizione visibile dal chiamante e quindi facilmente identificabile come l’esempio successivo. public class Database {

Connection Connection;

public enum databaseType {MySQL,Access,Oracle,SQLServer};

//Costruttore della classe Database

public Database(databaseType type,

String connectionString,

String user,

String password){

try {

switch(type){

case MySQL:

Class.forName("com.mysql.jdbc.Driver");

break;

case Access:

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

break;

case Oracle:

Class.forName("oracle.lite.poljdbc.POLJDBCDriver");

break;

case SQLServer:

break;

}

Connection = DriverManager.getConnection(connectionString, user, password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {


}

}

End class

Creando quindi una istanza alla classe Database, sarà possibile conoscere al tipologia di variabile e quindi specificare direttamente il valore in modo naturale e non in modo numerico.

Database db = null;

db = new Database(Database.databaseType.MySQL,"string","user","password");

Array o Vettori

Un array è una struttura dati omogenea, che contiene un numero finito di elementi dello stesso tipo, ad esempio un vettore di 10 interi. Questi elementi sono individuati attraverso un indice numerico, che tipicamente va da 0 al numero massimo di elementi meno uno. La dimensione del vettore deve essere dichiarata al momento della sua creazione. Vettori di dimensione diversa costituiscono tipi di dati diversi. 'accesso ad un elemento di un array ha un costo computazionale costante, mentre l'aggiunta o la rimozione di elementi in posizione casuale possono essere piuttosto onerose.

Di seguito viene mostrato un esempio di vettore solamente inizzializzato che in codice Java potrebbe essere definito in questo modo :

static int[] vettore = new int[10];

Come si nota sono già presenti 10 slot disponibili ma al loro interno non sono presenti i valori in quanto ancora non sono stati impostati.

È opportuno sottolineare che l’uso di vettori presuppone la conoscenza a priori del limite massimo degli elementi del vettore, poiché quando un vettore viene dichiarato, il compilatore ha la necessità di sapere quanta memoria dedicargli. Quindi, una volta compilato, un programma che fa uso di un vettore di n elementi non ne può utilizzare n + 1.

La maggior parte dei programmi che utilizzano Array si servono della struttura di controllo "cicli for" per attraversare gli array, ovvero per accedere sequenzialmente alle celle. Il ciclo for si presta molto naturalmente all'uso combinato dell'array proprio perché consente di specificare un tipo particolare di iterazione di un certo insieme di istruzioni, controllato da un indice che assume un insieme di valori solitamente interi e contigui.

Per esempio, il codice Java per stampare i contenuti di un array di 100 interi potrebbe essere come segue:

for(int i=0; i<100; i++) // per i crescente con passo 1 da 0 a 99

System.out.println(vettore[i]); // stampa la i-esima cella

Quindi ritornando alla figura precedente, se volessimo impostare un numero progressivo all’interno dei 10 slot presenti nell’array il codice Java potrebbe essere il seguente :

int[] vett = new int[10];

int i;

for (i=0; i<10; ++i)

{

vett[i] += i;

}

Di seguito viene mostrato come inizzializzare un array in Java, in questo caso contenente variabili di tipo float. float numero[] = {2.5f, 4.5f, 8.9f, 5.0f, 8.9f};

// notate la definizione di float con la f come

// ultimo carattere del valore

float somma = 0.0f;

for(int i=0; i<= 4; i++)

somma = somma + numero[i];

System.out.println("somma = " + somma); Un Array è possibile ridimensionarlo in quanto le locazioni di memoria presenti al suo interno non sono sufficenti per la nostra applicazione. Per far questo occorre creare un nuovo array e poi effettuare la copia e una assegnazione del nuovo Array al Vecchio così come viene riportato nel codice successivo.

public class Esempio {


System.out.println("Array non ancora ridimensionato");

int[] numbers = new int[1];

numbers[0]=2;

for (int i=0 ; i<1; i++){

System.out.println(numbers[i]);

}

System.out.println("Array ridimensionato");

int[] newNumbers = new int[3];

System.arraycopy (numbers, 0, newNumbers, 0, 1);

numbers = newNumbers;

numbers[1]=10;

numbers[2]=11;

for (int i=0 ; i<3; i++){

System.out.println(numbers[i]);

}

}

} In effetti occorre scrivere molto codice per poter lavorare con gli Array. Oltre agli Array, esistono anche degli oggetti che permettono un più facile accesso ai loro dati interni che vengono chiamati vettori. La classe che permette questo è la classe Vector presente all’interno del Package Java.Util.Vector. Di seguito vengono mostrati alcuni esempi di utilizzo di questa classe. Noteremo che rispetto ad un semplice Array, utilizzando questo oggetto è possibile una facile rimozione degli Items oltre che ad una veloce sostituzione dei valori all’interno del vector. //Definizione e creazione dell’istanza al vector

Vector dati = new Vector();

//Creazione dell'oggetto involucro tramite il costruttore della classe integer

Integer value = new Integer(20);

//Esempi di operazioni possibili con l'oggetto Vector

dati.addElement(value);

dati.insertElementAt("Mario Verdi",2);

dati.removeElementAt(2);

dati.setElementAt("Mario Rossi",2);

//per recuperare il valore dall'oggetto vector in una data cella

Integer numero = (Integer)dati.elementAt(0);

//conversione dall'oggetto involucro ad un int

int n = numero.intValue();

System.out.println("value " + n);

//per scorrere gli elementi del vettore un vettore

for (int i=0 ; i<dati.size() ; i++) {

Integer Value = (Integer)dati.elementAt(i);

System.out.println(Value.intValue());

}

I Cicli Un ciclo è un insieme di istruzioni che possono essere eseguite ripetitivamente sino a quando si verifica una determinata condizione. In Java esistono diverse tipologie di cicli, ogni tipologia ha delle caratteristiche che è opportuno conoscere bene.

Il ciclo For

Il ciclo for viene utilizzato quando si vuole eseguire delle operazioni un numero determinato (già conosciuto) di volte.

for (int i=0; i<10; i++)

{

System.out.println(i);

}

Nella definizione come vediamo dovrà essere presente una variabile di Indice, il limite massimo consentito e l’incremento. E’ possibile l’annidamento di più cicli For come nel caso successivo for (int i=1; i<11; i++)

{

for (int j=1; j<11; j++)

{

System.out.print(i*j + " ");

}

System.out.println();

}

Nel caso specifico verrà mostrata la tavola pitagorica da 1 a 10. E’ molto utile per scorrere Array con un numero di Items ben definito.

Il ciclo While

Ne esistono di diversi tipi. Come presupposto il ciclo termina quando una data condizione diventa vera. int i = 0;

while (i<10)

{


++i;

}

Questo esempio stampa il valore di i fino a quando i non diventa 10, in questo caso abbiamo dovuto dichiarare e assegnare prima il valore di i e dentro il blocco

while abbiamo incrementato il suo valore. Pertanto se i avesse contenuto il valore 10 non saremmo mai passati per il codice contenuto all’interno del blocco While. E’ possibile utilizzando il ciclo do while far si che almeno una volta il codice venga eseguito come nel caso succesivo. int x,i = 0;

do

{


++i;

}

while (x<10);

In questo caso la condizione viene testate solo alla fine del blocco dando modo al nostro flusso di passare almeno una volta le istruzioni contenute all’interno del do while. Questo è molto utile con i file quando occorre almeno una volta effettuare una lettura e poi testare se il file contiene dati oppure no.

Gli operatori Prima di parlare delle condizioni in Java occorre conoscere come utilizzare gli operatori matematici.

Gli operatori matematici

Di seguito quelli maggiormente utilizzati che servono per effettuare operazioni di addizione, moltiplicazione, divisione, ecc … + addizione (o anche concatenazione di stringe)

- sottrazione

/ divisione

* moltiplicazione

++ incremento

-- decremento

Gli operatori di espressione

Mentre nelle condizioni vengono utilizzati gli operatori di espressine che sono : = assegnazione

== ugualianza

!= differenza

> maggiore

< minore

&& e (AND logico)

|| o (OR logico)

! diverso da

E’ possibile inoltre concatenare gli operatori di espressione di modo da ottenere condizioni più complesse >= maggiore e uguale

<= minore e uguale

+= assegna e aggiunge un valore

-= assegna e sottrae un valore

Le condizioni

Una condizione è un modo per poter cambiare il percorso di esecuzione di un programma sulla base delle condizioni precedentemente acquisite. Come visto in precedenza vengono in nostro aiuto gli operatori matematici insieme all’utilizzo della IF. Un esempio di utilizzo : int x = 1; // utilizziamo l'operatore = di assegnazione

int y = x + 1; // y sarà uguale a 2

y += 10; // y diventa 12

if (x == y)

{

System.out.println("Primo risultato FALSO");

}

else if (y > x)

{

System.out.println("Secondo risultato VERO");

} Abbiamo visto come è possibile utilizzare gli operatori, analizziamo ora nel dettaglio cosa sono e come possiamo scrivere le condizioni in Java. Leggendo l'esempio qui sopra riportato vi troviamo una riga con la condizione if, seguita (tra parentesi) dalla condizione che x deve essere uguale a y. Avrei potuto anche omettere le parentesi graffe, infatti se l'istruzione che segue è una sola non c'è bisogno di racchiudere in blocco, ma è importante che almeno agli inizi vi abituate ad utilizzarle anche per una questione puramente di pulizia del codice. Seguendo troviamo la condizione else if, che indica una alternativa determinando una ulteriore condizione (se y è maggiore di x), anch'essa deve essere seguita da un blocco di graffe, nel caso in cui le istruzioni da eseguire siano maggiori di una. Una funzionalità messa a disposizione di Java è la clausola switch che permette di evitare un annidamento di IF per un test su una determinata variabile. int k = 10;

switch(k)

{

case 5: System.out.println(" case k = 5");

break;


break;


break;

default: System.out.println(" case default");

}

In questo esempio verrà scritto sullo schermo "case k = 10", perchè nel blocco switch troviamo 4 casi, determinati dalla parola chiave case e seguiti dal valore del caso e dai due punti. Importante dopo tutte le istruzioni prima dell'ultima è l'istruzione break; che indica al compilatore di non tenere presente cosa c'è scritto sotto e permette di andare avanti. L'ultimo caso non ha bisogno della parola chiave case perchè è la scelta predefinita, nel caso in cui k non sia ne uguale a 5, ne a 10 e nemmeno a 15.

L’accesso ai file Un file (termine inglese per "archivio") in informatica è un contenitore di informazione digitalizzata. Tecnicamente, i dati codificati in un file sono organizzati come una sequenza (di byte), immagazzinati come un solo elemento su una memoria di massa, all'interno del File system (sistema di archivi) esistente su una data memoria di massa. La manipolazione in Java dei file avviene utilizzando il pakage java.io. File f=new File("c:\nomefile.txt");

Leggere un file

Di seguito viene mostrato un semplice codice che in seguito alla creazione di una istanza all’oggetto file permette la sua lettura tramite gli oggetti Stream e Buffer. public void ReadFile(){

//creo l’istanza al file da leggere

File f = new File("prova.txt");

//creo l’istanza al flusso di Ascolto per prelevare le informazioni dal

//file passandogli l’istanza al file

FileInputStream fis = null;

try {

fis = new FileInputStream(f);

//Creo l’istanza di lettura dello Stream

//passandogli lo Stream precedentemente creato

InputStreamReader isr = new InputStreamReader(fis);

//Creo l’istanza al BufferedReader passandogli lo StreamReader

BufferedReader br=new BufferedReader(isr);

//Leggo la prima linea del file

String linea = br.readLine();

//Ciclo all’interno del file fino a che la linea è diversa da null

while(linea!=null) {

System.out.println(linea);

linea=br.readLine();

}

} catch (IOException e) {


}

}

Scrivere un file

Per scrivere un file invece possiamo utilizzare il seguente codice public void WriteFile(){

//Creo l’istanza all’oggetto file

File f = new File("prova.txt");

//Creo li FileOutputStream

FileOutputStream fos = null;

try {

fos = new FileOutputStream(f);

//Creo l’istanza a PrintStream passandogli l’oggetto fos.

PrintStream ps = new PrintStream(fos);

//Eseguo la scrittura di Hello World sul file

ps.println("Hello Word!");

} catch (FileNotFoundException e) {


}

}

Aprire un file già esistente in sovrascrittura

Se invece di creare (o sovrascrivere in caso di esistenza già del file) volessimo scrivere in coda a un file già esistente bisognerà aprire il file con la seguente istruzione:

FileOutputStream fos = new FileOutputStream(f,true);

Leggere i file contenuti in una directory

Ed ecco infine l’ultimo script per leggere tutti i nomi dei file contenuti in una particolare cartella:

public void ReadAllFileFromDirectory(){

//Creo l'istanza f all'oggetto file

File f = new File("c:\\");

//Testo se si tratta di una directory

if (f.isDirectory()) {

//Assegno ad un Array di stringe il contenuto del metodo

//list dell'oggetto file

String files[] = f.list();

//Effettuo il ciclo all'interno dell'oggetto file

//stampando i nomi dei file contenuti nella

//directory in esame

for(int i=0; i<files.length; i++)

System.out.println(files[i]);

}

}

Le eccezioni in Java Nel linguaggio di programmazione object-oriented Java, le eccezioni sono un modo chiaro per controllare gli errori, senza confondere il codice con tante istruzioni di controllo dell'errore. Quando si verifica una situazione di errore viene lanciata una eccezione, che se viene in seguito catturata permette di gestire l'errore, altrimenti viene eseguita dal supporto a tempo di esecuzione di Java una ruotine di default. Esiste in Java una classe Exception, e le eccezioni sono degli oggetti appartenenti a questa classe, quindi esse possono essere trattate come veri e propri componenti del linguaggio. Esempio di eccezione non gestita public class NestedFileNotFound {

public static void metodo2() throws IOException {

System.out.println(" Invocato metodo 2");

FileReader reader = new FileReader("input.txt");

BufferedReader in = new BufferedReader(reader);

String line = in.readLine();

System.out.println(line);

System.out.println(" Terminato metodo 2");

}

//Provare a togliere la clausola throws

// public static void metodo1() {



metodo2();


}

public static void main(String [] args) throws IOException {

System.out.println("Invocato main");

metodo1();

System.out.println("Terminato main");

}

} Esempio di eccezione gestita import java.io.*;

//Scaricare il file "input.txt"; compilare ed eseguire la classe;

//quindi cancellare "input.txt" e rieseguire la classe.

public class CatchFileNotFound {



FileReader reader = new FileReader("input.txt");

BufferedReader in = new BufferedReader(reader);

String line = in.readLine();

System.out.println(line);


}

public static void metodo1() {


try {

metodo2();

} catch (IOException ecc){

System.out.println("C'e' stato un problema in metodo2...");

}


}

public static void main(String [] args) {

System.out.println("Invocato main");

metodo1();

System.out.println("Terminato main");

}

}

Come possiamo vedere gestendo le eccezioni è possibile pilotare il codice ad effettuare determinate scelte a seguito dell’errore riscontrato. A parte le eccezioni standard è possibile creare delle eccezioni personalizzate creando una classe che estende Throwable, o meglio Exception , la quale è una estensione di Throwable. Supponiamo di volere creare una eccezione per dire che riferiamo una stringa vuota, scriveremo il programma public class ErroreStringaVuotaMain {


try {

Stampa(null);

} catch (ErroreStringaVuota e) {

//Metodo creato appositamente con la classe ErroreStringaVuota

e.PrintValue();

//Metodo che riporta tutta la trace dell'errore


}

}

public static void Stampa (String a) throws ErroreStringaVuota {

if (a==null) throw new ErroreStringaVuota(a);

else System.out.println(a);

}

} E l’eccezione particolareggiata che gestirà cose non gestite dalle normali eccezioni. public class ErroreStringaVuota extends Exception {

private Object value;

public Object getValue(){

return value;

}

public void PrintValue(){

System.out.println("Attenzione, la variabile inserita in input è

nulla!");

}

ErroreStringaVuota() {

super("Attenzione, stai riferendo una stringa non inizializzata");

}

ErroreStringaVuota(Object o) {

super();

value = o;

}

}

Scrivere bene il codice

I commenti sono parti del programma che non devono essere interpretate come istruzioni da eseguire, ma servono come indicazioni per una più agevole lettura del programma stesso da parte di chi non ne conosce la logica o anche come promemoria per il programmatore stesso.

Ogni linguaggio di programmazione ha un proprio sistema per indicare al compilatore/interprete di non considerare alcune parti del programma perché non avrebbero senso, in quanto sono dei commenti. Nel caso di Java è possibile commentare una singola riga inserendo il doppio slash

//Riga che verrà commentata

Ma è anche possibile commentare più righe di codice assieme inserendo

/*

righe che verranno commentate

*/

Se opportunamente utilizzati, i commenti possono costituire una valida documentazione al programma.

Spesso i programmatori tendono a non utilizzare affatto i commenti poiché per loro il codice è autoesplicativo. Il codice può essere già di per sé abbastanza autoesplicativo se si fa un uso oculato dei nomi di costanti/variabili e funzioni, si utilizzano le adeguate strutture dati e si fa uso della programmazione strutturata. Ma possono esservi parti più complesse all’interno del programma che è opportuno spiegare ulteriormente con un commento chiarificatore. Ricordatevi sempre, meglio perdere 5 minuti per scrivere un commento quando

si ha chiaro il funzionamento di una determinata parte del programma, piuttosto che perdere 30 minuti o più dopo un anno, per dover capire cosa effettivamente fa quella parte del programma. È ovvio che anche un uso troppo abbondante di commenti è da evitare, sia perché fa perdere troppo tempo in fase di stesura del codice, sia perché potrebbe risultare inutilmente tedioso nella rilettura del programma stesso.

Un’attività molto delicata

Scrivere programmi è un’attività delicata poiché sebbene sia relativamente facile scrivere programmi, è difficile scrivere buoni programmi.

Un buon programma non è solo quello che funziona, ma quello che oltre a funzionare, permette un’agevole manutenzione.

Di seguito sono elencate delle regole generali utili per la scrittura di buoni programmi, anche se l’esperienza e le capacità del programmatore rimangono comunque i fattori determinanti della bontà di un programma.

Quando si scrivono programmi, oltre a conoscere bene il linguaggio di programmazione utilizzato (la sua sintassi, le sue funzioni, ...) la prima cosa da non sottovalutare è la leggibilità del codice. Al computer non importa affatto della leggibilità del codice, ma è sufficiente che non vi siano errori di sintassi per poter eseguire il programma.

Bisogna però considerare che quel programma andrà manutenuto o comunque eventualmente corretto e quindi la sua correzione (che potrebbe avvenire anche in un momento piuttosto distante da quello di termine dei lavori o da persone diverse da quelle che lo hanno scritto) risulterà di gran lunga agevolata quanto più sarà facile comprenderne il codice. Quindi …

Occorre commentare bene i programmi

A tal fine, oltre ad essere estremamente consigliato l’utilizzo di un linguaggio di programmazione ad alto livello, si possono utilizzare vari espedienti, come l’uso di nomi esplicativi di varibili e funzioni, l’uso adeguato di commenti e dell’indentazione delle istruzioni.

Per migliorare la leggibilità del codice è anche opportuno seguire le regole della programmazione strutturata. Il riutilizzo di porzioni di codice già scritte è da incoraggiare, di fatto la programmazione Object Oriented lo fa ma ciò non deve andare a scapito della comprensibilità del codice.

In pratica, si tratta di eliminare i salti nell’ordine di esecuzione del codice a blocchi di istruzioni scritti qua e là nel programma (goto), preferendo una logica di esecuzione sequenziale ed utilizzando costrutti più vicini alla logica umana, come quelli seguenti

• istruzioni condizionali - costrutto if ... then ... else se la condizione X è vera allora esegui le seguenti istruzioni ... altrimenti esegui le seguenti istruzioni

• cicli di istruzioni - costrutto do ... while (o ciclo for each) se la condizione X è vera esegui le seguenti istruzioni ritorna ad eseguire il flusso del programma a partire dall’istruzione “se la condizione X è vera ...”

La sintassi dei linguaggi ad alto livello contiene questi tipi di costrutti, che aiutano a rendere più agevole e chiara la scrittura del codice.

Nota Bene : Esiste comunque anche un uso dei salti di esecuzione all’interno del codice che va incontro alla programmazione strutturata, ovvero che non va a scapito della chiarezza dei programmi. Questo accade quando tale istruzione è utilizzata per uscire dai cicli (anche annidati), anche se i linguaggi di programmazione mettono a disposizione apposite istruzioni per tale esigenza.

Parti di codice indipendenti e già collaudate, che devono essere riusate spesso nei programmi, possono essere utilizzate per formare delle librerie (ovvero scritte e compilate una volta per tutte e messe a disposizione per ulteriori utilizzi).

Inoltre, quando ci si accinge a scivere un programma è opportuno chiedersi se qualcun’altro si sia già scontrato con il problema che si tenta di risolvere, in modo da poterne eventualmente riutilizzare parte del codice (che magari è anche già testato).

L’indentazione del codice

Con il termine indentazione si indica il rientro verso destra delle righe di codice, in maniera tale che già dal primo impatto la struttura logica del programma possa risultare abbastanza chiara anche a chi non l’ha scritto. Ad esempio è una buona pratica indentare le righe contenenti le istruzioni da eseguire nei due rami di un blocco condizionale, come anche il blocco di istruzioni contenuto all’interno di un ciclo. Di seguito è riportato un semplice esempio in C

if (a == b) c = 0; else c = 1; b = c; A colpo d’occhio già si capisce che l’istruzione c = 0 verrà eseguita soltanto nel caso in cui le variabili a e b conterranno lo stesso valore, altrimenti verrà eseguita l’istruzione c = 1. In entrambi i casi sarà comunque eseguita l’istruzione successiva b = c che assegnerà alla variabile b il valore contenuto nella variabile c.

Un altro esempio (sempre in C) è riportato di seguito

while (a < b) { c += 2; a++; } b = 0;

Anche in questo caso è subito chiaro che le istruzioni racchiuse dal blocco di parentesi graffe, cioè quelle contenute all’interno del ciclo while sono quelle che vengono ripetute nel ciclo stesso, cioè finché il contenuto della variabile a è minore di quello della variabile b saranno ripetute ciclicamente le istruzioni c += 2 (che incrementa di 2 il valore contenuto nella variabile c, in maniera analoga a c = c + 2) e a++ (che incrementa di un’unità il valore contenuto nella variabile a, in maniera analoga a a += 1 o anche a = a + 1). Quando la condizione a < b non sarà più verificata (cioè a diventerà maggiore o uguale a b) verrà eseguita l’istruzione sucessiva b = 0

Regole da rispettare quando scriviamo codice

Quando scriviamo una classe ognuno di noi usa delle sue convezioni. Le convenzioni che occorre rispettare sono le seguenti :

• Tutte le variabili di classe devono essere private e devono essere dichiarate in alto alla classe e il loro nome sarà se composte da un singola parola tutta in minuscolo (per esempio name) se composta da più parole la prima lettera di ciascuna, a partire dalla seconda, in maiuscolo, tutte le altre minuscole (per esempio nameEmployee) • Tutte le variabili di classe devono essere esposte da proprietà (get e set) sia in lettura che in scrittura. • Tutte le costanti presenti nella classe dovranno essere in lettera maiuscole e lo spazio tra una parola e l’altra dovrà essere preso dal valore “_”underscore (per esempio COSTANTE_DI_INCREMENTO) • Tutti i nomi dei metodi dovranno se composti da un singola parola essere scritti in minuscolo (per esempio name) se composti da più parole la prima lettera di ciascuna, a partire dalla seconda, in maiuscolo, tutte le altre minuscole (per esempio nameEmployee)

introduzione alla programmazione java

Documents