Appunti per Esame Programmazione orientata agli oggetti

API - Application Program Interface

Tutto ciò che si deve sapere per usare le classi.

Classi stringhe di caratteri

In Java le stringhe e gli array sono oggetti, dunque sono allocati nell'heap a seguito di una operazione new (implicita o esplicita). Le stringhe vengono considerate come array di caratteri.

Le stringhe appartengono alla classe String di java.lang, che fornisce diversi metodi per la loro manipolazione. Gli oggetti String sono immutabili: una volta creata una stringa, essa non può più essere modificata. Tuttavia, data una variabile String s si può sostituire in s il riferimento ad un oggetto stringa con il riferimento ad un altro oggetto String.

String s = "casa"; // è presente una new implicita
s.length(); // metodo per ottenere la lunghezza della stringa

Gli oggetti di String sono dotati del confronto naturale (compareTo() o lessicografico). Il confronto è case-sensitive. Anche equals() è case-sensitive. Esiste...

equalsIgnoreCase() che verifica l'uguaglianza ignorando il caso dei caratteri.

Metodi di String uso ricorrente .trim(), toglie tutti gli spazi che precedono e seguono la frase.

nextLine(), prende tutta la riga fino al capolinea.

split(), divide la string in pezzi, per esempio prima e dopo le virgole.

Proliferazione di stringhe garbage.

L'immutabilità delle stringhe comporta che molti metodi costruiscono una nuova stringa e la ritornano, così che un vecchio oggetto string venga buttato via e sia rimpiazzato da uno nuovo.

Le stringhe che hanno perso il loro riferimento saranno raccolte dal garbage collector.

StringBuffer o StringBuilder.

Sono due classi di java.lang di stringhe mutabili che utilizzano un array sottostante scalabile dinamicamente.

Il metodo più interessante è append(). Esso riceve un valore di tipo primitivo o un oggetto, lo converte a stringa di caratteri e concatena questi caratteri al contenuto attuale dello string builder se necessario.

Si suggerisce di dimensionare lo String Builder inizialmente ad una capacità opportuna per evitare la riallocazione dell’array sottostante che avrebbe effetti simili a quelli visti con le stringhe garbage

Il costruttore di default StringBuilder() crea uno string builder con capacità iniziale di 16 caratteri

Il costruttore StringBuilder(capacità) crea uno string builder di una certa capacità (iniziale)

Il metodo int capacity() consente di ispezionare il valore corrente della capacità

capacità != dimensione effettiva

dimensione effettiva = il numero effettivo di elementi.

Argomenti di un programma

È noto che il metodo main riceve un array di String. I valori di questo array sono specificati, nella riga di comando che lancia l’esecuzione, subito dopo il nome del programma, e separandoli da spazi.

Esempio:

c:\poo-java\java poo.string.TestArguments 10 8 12 -3 5 7

In questo caso viene chiesta l’esecuzione

del metodo main della classe TestArguments e viene costruito un array di stringhe con i valori che seguono il nome del programma. In generale, l'uso di argomenti dal programma è consigliabile quando sono in gioco pochi valori. Diversamente, occorre effettuare le operazioni di Input. Tokenizzazione di una stringa: Spesso quando abbiamo una stringa si desidera frammentarla nei suoi costituenti (token). Ciò è possibile con tre classi diverse: 1. String Tokenizer La classe StringTokenizer di java.util permette di fare ciò in modo più intuitivo. I costruttori più interessanti sono: StringTokenizer(String string, String delimitatori) StringTokenizer(String string, String delimitatori, boolean ritornoDelimitatori) Nel primo caso i delimitatori consentono di individuare il prossimo token, ma i delimitatori non vengono restituiti come token, ciò che avviene con il secondo costruttore. String nextToken() ritorna il prossimo token Boolean hasMoreToken() il

metodo controlla se esistono altri token nella stringa

Esempio:2. Tokenizzazione mediante uno Scanner

La suddivisione in token di una stringa-linea può essere ottenuta tramite la classe Scanner e metodi associati

3. Tokenizzazione mediante il metodo split

Delimitatore caratteri di word

I caratteri di word sono: lettere maiuscole, minuscole, cifre, underscore e dollaro

“//W+” uno o più caratteri di word sono separatori

“W+” uno o più caratteri di word

Quando dobbiamo inserire dei dati da input, tra la tastiera e il nostro programma è presente un buffer, alla ricezione dell’invio verrà effettuato lo shuffling.

Tipi di dati astratti

Spesso le applicazioni utilizzano dati strutturati (aggregati) che si caratterizzano per le operazioni che si possono eseguire e non per il modo in cui sono implementati. Tutto ciò introduce il concetto di ADT (Abstract Data Type) che in Java è esprimibile tramite interfaccia o una classe astratta.

Si tratta di un pacchetto di metodi (contratto) specificati unicamente mediante la loro intestazione.

Un ADT è poi concretizzabile in diversi modi.

Un esempio di ADT:

Si vuole realizzare un vettore che è più "comodo" per le applicazioni. Gli array nativi quando facciamo molti rimozioni e inserimenti in punti intermedi, o inserimenti di un elemento quando l'array è pieno, tendono ad introdurre problemi. Un vector è pensato per scalare dinamicamente di dimensione ogni volta che serve, e farsi carico delle eventuali operazioni di spostamento di elementi in seguito ad inserimenti o rimozione.

Un Vector generico e parametrico:

Per realizzare un vettore omogeneo usiamo i generici, ossia la possibilità di programmare una classe/interfaccia (o anche singoli metodi) in veste generica in uno o più tipi. Utilizzando i generici, l'ADT Vector diventa più flessibile e sicuro. Ad esempio:

public interface

Vector<T>{}//Vector

La notazione Vector<T> significa che la struttura dati (aggregato) è composta di elementi tutti di un stesso tipo T al momento non meglio specificato. In pratica T sta per una qualsiasi classe Java. T viene chiamato parametro tipo. Con tale organizzazione, il compilatore garantisce che nel vettore non si possano inserire elementi che non siano oggetti T (omogeneità).

Classi wrapper dei tipi primitivi

Poiché il parametro formale T di una classe generica come ArrayVector<T> denota una qualsiasi classe Java, non è possibile utilizzare i tipi primitivi (che non sono classi).

Nel package java.lang, introduce classi predefinite che sono associate ai tipi primitivi:

• byte -> Byte
• short -> Short
• long -> Long
• float -> Float
• double -> Double
• char -> Character
• boolean -> Boolean
• int -> Integer
• double -> Double

Un oggetto di una classe wrapper è

immutabile perché rappresenta una costante di un tipo primitivo sebbene sotto forma di oggetto Vector<T> generico e parametrico. Data l'assenza di specifiche sulla classe non è possibile istanziare T, gli oggetti di tipo T possono essere ricevuti/restituiti da metodi. Nemmeno la creazione di un array di tipo T è consentita. Tuttavia, la difficoltà può essere aggirata creando un array di Object e poi castizzando tale array al tipo (T[]).

Tipi "grezzi" e tipi generici. Quando una classe/interfaccia come Vector<T> o ArrayVector<T> è usata senza l'informazione esplicita di tipo, si sottintende Object come tipo degli elementi e la classe denota un tipo grezzo. L'utilizzo di una classe/interfaccia generica e parametrica è opportuno che avvenga in veste tipata e non in forma grezza.

Collection Framework. L'interfaccia Iterator<T>. L'interfaccia è utile per "navigare" sulla

collection elemento per elemento, dal primo all'inizio la freccia dell'iterator è posizionata prima del primo elemento, poi viene posizionata in mezzo a due elementi. Chiamare next() quando hasNext() ritorna false, solleva la RuntimeException NoSuchElementException(). Elemento corrente-> quello che viene restituito dopo la next(). Il metodo remove() consente di rimuovere l'elemento corrente, rilasciato dall'ultima next(), dalla collezione. Chiamare remove() non preceduta da una chiamata next() solleva la RuntimeException IllegalStateException. L'interfaccia Iterable espone un solo metodo iterator(), una classe si dice iterabile se implementa l'interfaccia iterable. In queste condizioni il compilatore conosce a priori che un qualunque oggetto della classe dispone di un iteratore che di può ottenere invocando il metodo standard iterator(). Avendo l'Iterator, alcuni metodi possono essere svolti nei piani alti. Piani alti e piani.bassi Nei piani alti viene definito ciò che si deve sviluppare, nei piani bassi invece definiamo come implementare i nostri tipi.
L'iterator sarà ridefinito nelle classi concrete.
Ciclo for-each
Un altro tipo di Iterazione è il ciclo for-each, chiamato anche ciclo implicito.
Avendo un iteratore implicito, non è possibile effettuare una rimozione di un elemento durante un for-each.
Supponiamo di avere un metodo definito nell'interfaccia e un override del metodo nella classe astratta, verrà richiamato allora il metodo della classe astratta. Essendo ogni classe erede di Object, non è possibile definire i metodi equals, hashCode, toString nelle interfaccie perché verrebbero richiamati i metodi presenti in Object.
Le inner class
L'inner class è una classe interna che viene programmata dentro una classe outer.
L'inner class è una classe privata e quindi non accessibile dall'esterno. Queste classi vengonousatesoprattutto per ottenere un Iterator, quando si chiede l'iterator tramite il metodo iterator(), si istanzia la inner class e si ritorna l'istanza creata. In alcuni casi, la inner class non necessita di accedere ai dati della outer class, è quindi opportuno evitare l'aggravio di memoria dovuto al riferimento nascosto tra istanza inner e corrispondente istanza outer, programmando la classe inner in versione static. La classe accede ai campi dell'outer. Iterator su ArrayVector L'implementazione della inner class Iterator si basa su un indice corrente inizializzato a -1, ad indicare che si trova prima del primo elemento. Durante l'iterazione, l'indice o vale -1 o riferisce ad un elemento del vector che è già stato restituito. Il metodo hasNext() ritorna true o perché l'indice vale -1 ma size()>0 o perché è minore size()-1: in entrambi i casi è possibile res