Riepilogo JAVA Prima Parte

D: COSA E' 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

E' 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;

}

D: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

}

}

D: 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! E' 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

D: 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.

D: 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;

D: E' 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 indipendemente dagli oggetti della classe ed

è possibile accedere ad essere 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.

D: 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.

D: 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 apparterà 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

D: 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);

}

}

D: 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(a==b); //stamperà false

D: Esiste un modo per rendere 2 stringhe uguali (non assegnate col new) 2 oggetti

diversi?

R: Sì, è sufficiente spezzare una delle due nel seguente modo

String a=”parola”;

String b=”par”; b+=”ola”;

System.out.println(a==b); //stamperà false

D: Qual è il formato delle stringhe in Java?

R: Le stringhe in Java usano caratteri Unicode a 16 bit (estensione di ASCII)

D: Come si concatenano 2 stringhe o 1 stringa con un altro letterale ?

R: Sì concatenano con l'operatore '+' che, nel caso di stringa+letterale, trasforma il

letterale in stringa

Esempi:

String a=”Par”;

String b=a+”ola”; //b=”Parola”;

int j=5;

String c=”Numero “+j//c=”Numero 5” dove j viene convertito in stringa

D: Come si confrontano 2 stringhe?

R: Essendo che String non è un tipo fondamentale, ma una classe di sistema, e quindi

referenzia un oggetto, per il confronto si usa il metodo equals invocato sul primo

riferimento e che prende a parametro il secondo riferimento:

Esempio

String a=”ciao”;

String b=”ciao”;

String c=”buongiorno”;

System.out.println(a.equals(b)); //stamperà true

System.out.println(a.equals(c)); //stamperà false

System.out.println(b.equals(c)); //stamperà false

Analogamente esiste il metodo equalsIgnorCase, che permette di confrontare due stringhe

senza tener conto di maiuscole e minuscole

D: C'è almeno un metodo per confrontare l'ordine lessicografico di due stringhe ?

R: Sì, si invoca sul primo riferimento il metodo compareTo e si passa a parametro il

secondo riferimento. Il metodo restituisce -1 se la prima stringa è prefisso della seconda,

viceversa ritorna 1; ritorna 0 se le 2 stringhe sono uguali, oppure la differenza tra le prime

due lettere diverse

Esempio:

String a=”ciak”;

String b=”ciao”;

String c=”ciao”;

System.out.println(a.compareTo(b)); //stamperà -4

System.out.println(b.compareTo(a)); //stamperà 4

System.out.println(b.compareTo(c)); //stamperà 0

Esiste anche il metodo compareToIgnoreCase che ignora eventuali maiuscole e/o minuscole.

Altri metodi sono startsWith ed endsWith che ritornano true se la stringa in