Riepilogo JAVA Prima Parte

Javad: cosa è una classe?

R: Una classe è un modello per creare e manipolare oggetti. Una classe è costituita da un blocco in cui sono presenti le specifiche dei suoi oggetti e, per questi, la classe deve descrivere: gli stati possibili attraverso gli attributi, che sono delle variabili;– i comportamenti tramite i metodi.–

Cos'è un oggetto?

R: Un oggetto è un'istanza di una classe che ne determina il tipo. Ogni oggetto ha: un'identità, cioè un suo codice identificativo e uno spazio in memoria; uno stato, definito da attributi, che sono variabili conservate nell'oggetto; un comportamento, definito da metodi che ne fanno cambiare lo stato.

Qual è la sintassi dei metodi?

I metodi vanno scritti nel seguente modo:

<modif_visibilità><tipo_return_value><nome_metodo>(<parametri>*){
//lista di istruzioni e variabili locali;
//se il metodo ha un valore di ritorno diverso da VOID deve contenere almeno un return;
}

Esempio

public int somma(int a, int b){return a+b; //ritorna un int}
public void somma(int a, int b){System.out.println(“”+a+b);//stampa la somma tra a e b}

Le variabili locali

Le variabili locali sono quelle variabili dichiarate all'interno di un metodo e alla fine dell'esecuzione del metodo in cui sono contenute, esse cessano di esistere, a differenza delle variabili d'istanza (attributi della classe) che cessano di esistere quando l'oggetto non è più referenziato. Sia per le classi, che per le variabili e per i metodi viene specificato un modificatore di visibilità. Non specificarlo non comporta errori, ma ha un significato preciso per gli attributi e i metodi: sono accessibili solo dalla classe in cui sono contenuti e dal package. La gerarchia dei modificatori, dal meno al più restrittivo, è: public, protected, nessuno, private.

Come istanziare gli oggetti della classe

R: Per istanziare gli oggetti della classe si definisce all'interno della classe un metodo speciale detto costruttore che ha lo stesso nome della classe e non ha valore di ritorno. Se tale costruttore non viene specificato, come meccanismo di salvaguardia, il compilatore aggiunge il costruttore di default:

Esempio:

public class Persona{….public Persona(){….}….}

è lo stesso di

public class Persona{….}

Esistono valori di default per le variabili istanza?

R: Sì! Le variabili di istanza, se non hanno un valore assegnato al momento della loro creazione, vengono inizializzate ad un valore di default che dipende dal tipo di dato: 0 (zero) per int, long, short; 0.0 (zero.zero) per float e double; \u0000 per i char (\u0000 è il carattere null con codifica Unicode 16 bit); null per i riferimenti a oggetti; false per i boolean.

A differenza delle variabili d'istanza, le variabili locali devono essere inizializzate esplicitamente.

Esistono convenzioni in Java?

R: Sì: i nomi delle classi iniziano per lettera maiuscola; i nomi dei metodi si scrivono in minuscolo; i nomi degli attributi si scrivono in minuscolo; i nomi delle costanti (final) si scrivono in maiuscolo. In caso di nomi composti si usa la notazione a cammello (Camel Case) per i primi tre casi, e il carattere _ per separare le parole delle costanti.

Esempi Camel Case:

• Classe: public class LibroPrestabile{...}
• Attributi: private String nomeAutore;
• Metodi: public int getId(){...}

Esempi di costanti con parole composte:

• final int MAX_VALUE=2000;
• final String NOME_BIBLIO=”La Biblioteca”;

Tipi fondamentali e riferimenti ad oggetti

In Java esistono 2 tipi di variabili:

• Tipi fondamentali:
• byte, intero 8 bit con segno
• short, intero 2 byte
• int, intero 4 byte
• long, intero 8 byte
• float, virgola mobile 32 bit
• double, virgola mobile 64 bit
• boolean, true o false a 8 bit
• char 16 bit Unicode

Come si crea un oggetto?

R: Un oggetto viene creato attraverso l'operatore new che invoca un costruttore e restituisce un riferimento all'oggetto appena creato. Esempio:

Quadrato q = new Quadrato(); // creiamo un oggetto tipo Quadrato e lo salviamo nella variabile q

q referenzia un oggetto di tipo Quadrato. Gli oggetti vengono sempre acceduti tramite i loro riferimenti. Se manca il riferimento, l'oggetto non è più accessibile:

Es.: Persona p=new Persona(); Persona t=new Persona(); p=t; //l'oggetto che era stato assegnato a p non ha più riferimenti

Cos'è il Garbage Collector?

R: Il G.C. della JVM si occupa di liberare dalla memoria gli oggetti che non hanno più riferimenti, quindi non occorre deallocare manualmente la memoria. La JVM gestisce un contatore dei riferimenti per ogni oggetto e quanto tale contatore è a 0 l'oggetto viene deallocato automaticamente.

Es. Persona p,t; p=new Persona(); t=p; /* t e p sono riferimenti allo stesso oggetto */ t = null; s = null; /* l'oggetto di tipo Persona non è più accessibile e sarà cancellato */

Come si confrontano 2 riferimenti a 2 oggetti?

R: Due riferimenti ad oggetti si confrontano con l'operatore ==. Se i 2 riferimenti contengono lo stesso oggetto, allora verrà restituito il valore true, altrimenti false.

Es. Persona s,t; s=new Persona(); t=new Persona(); System.out.println(s==t); //restituirà FALSE s=t; //ora i 2 riferimenti contengono lo stesso oggetto System.out.println(s==t); //restituirà TRUE

Invece due oggetti si confrontano con il metodo equals invocato sul riferimento del primo oggetto e prendendo a parametro una copia del riferimento al secondo oggetto. Se l'oggetto referenziato dal primo riferimento è uguale all'oggetto referenziato dal secondo, allora verrà restituito TRUE, altrimenti FALSE.

Esempio: String a,b; a=new String("abc"); b=new String("cde"); /* a contiene l'oggetto di tipo Stringa che prende a param del costruttore la stringa “abc”, mentre b prende a param del costruttore la stringa “cde”, quindi i due oggetti referenziati da a e b sono diversi */ System.out.println(a.equals(b)); //stampa false

Come si accede agli attributi e come si invocano i metodi?

R: Per accedere agli attributi e per invocare i metodi della classe si usa la notazione punto (dot notation) sul riferimento all'oggetto.

Es.: int j; Persona s=new Persona(); j=s.eta; //accedo all'attributo eta s.presentati(); //invoco il metodo presentati

Come si dà vita agli oggetti della classe?

R: Per far vivere gli oggetti della classe, viene inserito un metodo speciale, il main, nel quale vi sono le istruzioni per creare e manipolare gli oggetti. Il main va obbligatoriamente scritto nel seguente modo: public static void main (String[] args)

Come si compila ed esegue un programma in Java?

R: Per compilare un programma in Java, bisogna aprire il terminale sulla cartella (o cartelle) dove sono presenti le nostre classi (o la nostra classe) e digitare sul terminale: javac <nomefile>.java

Mentre per eseguire il programma, bisogna digitare sul terminale: java NomeClasse (senza estensione .class)

Si ricorda che il nome del file .java deve essere uguale al nome della classe: Es. la class Persona deve essere salvata come Persona.java Inoltre un file .java può avere più classi, ma solo una può essere marcata public e tale classe deve avere appunto lo stesso nome del file. Se più classi hanno il metodo main, verrà eseguito solo quello della classe marcata public. È consigliato, inoltre, nel caso in cui il programma contenesse più classi, aggiungere una classe Main con il solo metodo main. Se mettessimo diversi file .java nella stessa cartella, o diverse classi nello stesso file, ogni classe può accedere agli attributi e ai metodi di un'altra classe, eccetto quelli marcati come private. (Ricordiamo che se non si mettono modificatori di visibilità, allora gli attributi e/o i metodi senza m.d.v. saranno accessibili solo fino a livello di package, ma non nelle sottoclassi e né ovunque).

Come si crea la documentazione in Java?

R: In Java i programmi vengono distribuiti già compilati e per sapere come usarli non si vede il codice sorgente, ma la documentazione. Per produrre tale documentazione si usa un sistema chiamato Javadoc che, tramite commenti speciali inseriti nel codice sorgente, crea dei file HTML che contengono la descrizione del programma e di come esso si usa. Tutti i commenti per la javadoc iniziano con /** e finiscono con */

Nella documentazione è possibile inserire tag quali:

• @author <nome autore> per l'autore
• @version <info> per la versione
• @see <nome classe> per creare dei link ad altre classi
• @see <package.nomeclasse> per creare dei link ad altre classi
• @see <nomeclasse#nomemetodo> per creare link a un metodo della classe
• @since <version> per dire da quale versione è disponibile quella classe/attr/metodo
• @param <param><descriz> per descrivere i parametri dei metodi
• @return <descrizione> descrive valore ritorno
• @throws <eccezione><descrizione> descrive un'eccezione
• @deprecated <descrizione> descrive il motivo della deprecation

Per generare la documentazione si digita: javadoc [opzioni] [nomipacchetti][files][classi] Esempio javadoc -d docs *.java

Cosa è l'incapsulamento dei dati?

R: L’incapsulamento è un meccanismo attraverso il quale gli attributi e/o i metodi di una classe sono protetti da accessi decisi dal programmatore. Tali accessi vengono definiti da dei modificatori di visibilità: public, protected o private.

• Public: l'attributo e/o il metodo è accessibile ovunque
• Protected: solo in classe e sottoclasse e al livello di package
• Private: solo nella classe dove l'attributo e/o il metodo risiede

È buona norma marcare public i metodi e i costruttori e private gli attributi. NON si devono inserire modificatori di visibilità né per le variabili locali, né per i parametri:

Esempio errato:

public int somma(public int a, public int b){ //mdv nei parametri public int c=a+b; //mdv per la var locale c return c;}

Esempio corretto:

public int somma(int a, int b){ int c=a+b; return c; }

Oppure:

public int somma(int a, int b){ return a+b; }

Quando richiamiamo un attributo della classe in un metodo, implicitamente a cosa ci stiamo riferendo?

R: Quando richiamiamo un attributo della classe in un metodo, implicitamente ci stiamo riferendo alla variabile dell'oggetto a cui verrà applicato il metodo e, talvolta, può essere utile esplicitare questo parametro utilizzando il riferimento this!

Esempio:

public class Serbatoio{

final int CAPACITA=500;

public int getCapacita(){ return this.CAPACITA; } //CAPACITA è un attributo costante della classe richiamato dentro il metodo getLivello();

public static void main(String[] args){ Serbatoio s=new Serbatoio(); //oggetto a cui verrà applicato... System.out.println(s.getCapacita()); //...il metodo }}

Ci possono essere più metodi con lo stesso nome?

R: Sì, ci possono essere più metodi con lo stesso nome, ma devono differire per numero o tipo o ordine dei parametri (firma del metodo). Questo meccanismo si chiama overloading di metodi. Un caso molto usuale di overloading lo troviamo nei costruttori, in modo che si possono costruire oggetti utilizzando parametri diversi. Se nell'overloading cambia solo il valore di ritorno, il compilatore genera un errore, a meno che non siano stati cambiati anche i parametri.

Esempio

int metodo(int a, int b) double metodo(double a, double b) //OK! Stiamo facendo overloading double metodo(int a, int b)//ERRORE! È cambiato solo il valore di ritorno

In caso di overloading con parametri numerici di tipi compatibili, ci sono delle regole automatiche di scelta: tipi come byte e short vengono interpretati come int, mentre float come double.

Possiamo usare il this come metodo?

R: Sì, possiamo usare il this, seguito da (), cioè this(), per invocare un costruttore all'interno di un altro costruttore, e questa deve essere obbligatoriamente la prima istruzione dell'altro costruttore:

Esempio

public Persona(String nome){ this.nome=nome; }

public Persona(String cognome){ this(nome); this.cognome=cognome; }

Quindi verrà costruito un oggetto con i parametri specificati tra parentesi in modo da poter modificare gli altri parametri nelle istruzioni successive. Il compilatore capisce quale costruttore invocare col this vedendo la lista dei parametri.

Come si dichiarano le costanti?

R: Le costanti si dichiarano con la parola chiave final. Sono non modificabili e vanno inizializzati al momento della dichiarazione (consigliato) oppure in tutti i costruttori. Per convenzione le costanti si scrivono tutte in maiuscolo e separate da underscore nel caso di parole composte:

Esempio

final int CAPACITA=200;
final int MAX_VALUE=100;

È possibile definire attributi di classe, cioè propri della classe e non dei suoi oggetti?

R: Sì, è possibile, e lo si fa anteponendo all'attributo la parola chiave static. Gli attributi static vengono allocati in memoria indipendentemente dagli oggetti della classe ed è possibile accedere ad essi senza istanziare oggetti della classe. L'allocazione in memoria di un attributo static è indipendente dagli oggetti della classe che contiene quell'attributo. Ci sono 3 modi per richiamare un attributo static:

• a sé stante, a patto che sia nella classe stessa;
• nomeriferimento.nomeattributo;
• nomeclasse.nomeattributo;

Stesso ragionamento vale anche per i metodi static: possono essere usati senza istanziare oggetti della classe. Un esempio di metodo static è il metodo main che deve essere necessariamente tale perché viene invocato il primo di tutti, quindi quando nessun oggetto è stato ancora creato.

Cosa sono e come vengono passati i parametri dei metodi?

R: I parametri sono delle variabili che possono essere tipi fondamentali, riferimenti a oggetti, ma anche array. I parametri vengono passati sempre per valore, a prescindere se il parametro sia un tipo o un riferimento ad oggetto. Cioè al metodo viene passata una copia della variabile la quale, essendo locale, cesserà di esistere alla chiusura del metodo. È errato dire che gli oggetti vengono passati per riferimento. Sono i riferimenti agli oggetti che vengono passati per valore.

Quindi quando noi passiamo le variabili a parametro ai metodi dobbiamo sempre ricordare che se ne sta passando una copia, che sarà una variabile locale del metodo e che quindi scomparirà alla fine del metodo.

Cosa è un package?

R: Un package è una struttura di classi appartenenti allo stesso progetto, generalmente per essere distribuito. Ogni classe del package deve iniziare con la dichiarazione del package

Esempio:

package geometria.figurepiane;/* eventuali import */
public class Rettangolo{//corpo della classe}

Nell'esempio la classe rettangolo apparterrà al package geometria.figurepiane; Se avessimo ad esempio quest'altra classe:

package geometria.figuresolide;/* eventuali import */
public class Cubo{//corpo della classe}

la classe Cubo apparterrebbe al package geometria.figuresolide;

Quindi, una volta messi tutti i file .java dentro una cartella src, ci si sposta nella cartella che contiene src e si apre il terminale in questa cartella. Fatto ciò si digita:

javac -d ./ ./src/*.java

Nel caso in cui avessimo le classi sopra citate (Rettagolo e Cubo che rispettivamente appartengono ai package geometria.figurepiane e geometria.figuresolide), al momento della compilazione, nella cartella contenente src, verrà creata la cartella 'geometria' che conterrà due sottocartelle: 'figurepiane' e 'figuresolide'.

Esempio di albero di cartelle:

• -src
• -Rettangolo.java
• -Cubo.java
• -geometria
• -figurepiane
• -Rettangolo.class
• -figuresolide
• -Cubo.class

Come testare le classi di un package?

R: Per testare le classi di un package, un suggerimento è quello di creare una classe Main nella cartella che contiene 'src' e, prima del corpo della classe, inserire:

import <percorsopackage.*> // * indica tutte le classi del package (consigliato) o al posto di *, richiamare le singole classi import <percorsopackage.NomeClasse>

Un esempio

import geometria.figurepiane.*; public class Main{ public static void main(String[] args){ Rettangolo r=new Rettangolo(); double a=r.getArea(15,20); }}

String è un tipo fondamentale o una classe?

R: String è una classe di sistema, sita nel package java.lang, che permette di creare stringhe, quindi le stringhe sono oggetti, istanze della classe String. Nonostante ciò non è necessario utilizzare l'operatore new, infatti si può assegnare al riferimento un letterale stringa tra doppi apici.

Esempio:

String s=”Parola”;
String s=new String(“Parola”);

Le stringhe sono oggetti immutabili, cioè una volta creati non possono essere modificati. La JVM gestisce un 'pool di stringhe' per risparmiare memoria. Stringhe uguali verranno viste come lo stesso oggetto:

Esempio

String a=”pippo”;
String b=”pippo”;
System.out.println(a==b); //stamperà true

Però le stringhe inizializzate con l'operatore new non faranno parte del pool di stringhe.

Esempio

String a=”pippo”;
String b=new String(”pippo”);
System.out.println(