Lezione n° 10 Istituto Statale di Istruzione Superiore “F. Enriques” Corso JAVA.

Lezione n° 10

Istituto Statale di Istruzione Superiore “F. Enriques”

Corso JAVA

2

I Package.

In questa lezione vedremo cosa sono i package e come si utilizzano:

Un package è una libreria, ovvero una collezione di classi logicamente connesse che possono interagire tra loro.

Java dispone di una serie di package standard che possono essere importati da qualsiasi programma, a cui si aggiungono tutti i package che un utente può creare autonomamente, quindi l’insieme dei package che si possono utilizzare è potenzialmente infinito.

L’organizzazione dei package ha una struttura gerarchica per l’assegnamento dei nomi alle classi in modo da evitare eventuali collisioni in caso in cui alcuni programmatori usino lo stesso nome per differenti definizioni di classe.

Corso di Programmazione in Java – Lezione n° 10


3

I Package (2)

I vantaggi nell’usare i package sono i seguenti:1) Le classi possono essere mascherate all’interno dei package

implementando l’incapsulamento anche a livello di file, per nasconderne quindi il funzionamento all’utente finale a cui deve interessare solo il risultato finale.

2) Le classi di un package possono condividere dati e metodi con classi di altri package.

3) I package forniscono un meccanismo efficace per distribuire oggetti.I package che si trovano più spesso all’interno di programmi sono i seguenti:

java.lang: per la funzioni comuni del linguaggio.java.util: per altre utili funzioni di servizio.java.io: per input ed output.java.text: per la formattazione di input ed output.



4

I Package (3)

Per ottenere l’accesso a ciascuno di questi package, eccetto lang che è sempre disponibile, si utilizzerà la parola chiave import seguito dal nome del package di cui si vuole ottenere l’accesso.

La sintassi per ottenere l’accesso ad una specifica classe di un package è:import java.gruppo_package.nome_classe;

Se invece si vuole ottenere l’accesso a tutte le classi che appartengono ad un package si può invece utilizzare la sintassi seguente:import java.gruppo_package.*

Poiché non c’è degrado delle prestazioni associato all’importazione dell’intero package rispetto all’importazioni di singole classi dello stesso package, molti programmatori usano sistematicamente il simbolo .*

I package sono un esempio lampante del riutilizzo del codice, ovvero uno dei vantaggi della programmazione ad oggetti di cui abbiamo parlato nelle prime lezioni.



5

I Package (4)

All’inizio della diapositiva precedente abbiamo detto che il package lang è l’unico ad essere sempre disponibile.

In particolare il package java.lang contiene il nucleo del linguaggio Java, in particolare contiene le classi:

– Object– String– System– Math, ecc..

Il package java.util implementa utilities per il programmatore, tra cui– Date– Random– Classi per strutture dati (Vector, Stack, Hashtable,…)

Che molto probabilmente utilizzeremo prima o poi nel resto del nostro corso.



Vedete niente di familiare?

String che non fa parte dei tipi fondamentali, ma è una classe di java.lang

Abbiamo già utilizzato anche System… per le stampe: System.out.println()

6

I Package (5)

E’ possibile creare un proprio insieme di classi da racchiudere in un package.

Per fare ciò è necessario scrivere la seguente istruzione all’inizio del file Java che contiene le classi da racchiudere nel package:

package nome_mio_package;

Se si inserisce la stessa dichiarazione in un altro file java, si indica al sistema che pure quel file fa parte dello stesso package.

Se un file non contiene una dichiarazione di package, allora alle classi di tale file viene associato automaticamente il package di default, il cosiddetto package senza nome.

In questo corso non ci preoccuperemo tanto della creazione di nuovi package, quanto all’utilizzo di package esistenti, per tali motivo vediamo l’esempio seguente:



7

Esempio utilizzo di un package

Esempio fare la somma di 10 numeri casuali compresi tra 0 e 99:import java.util.Random;class Main{

public static void main(String[] arg) {Random generatoreRandom = new Random(); \\ Random è una classe di java.util.RandomSystem.out.print(“La somma dei seguenti numeri ”);int numero_corrente, somma;for ( int i = 0; i < 10; i++ ){

numero_corrente=generatoreRandom.nextInt(100);System.out.print(numero_corrente + “ ”);somma = somma + numero_corrente;

}System.out.println(“ è uguale a : ” + somma);

}}



8

Alcune delucidazioni sull’esempio precedente.

Nell’esempio precedente è stata utilizzata la libreria Random che contiene la definizione degli oggetti Random che permettono di utilizzare la generazione di numeri casuali.

Per utilizzare un generatore di numeri casuali è stato quindi necessario istanziare un oggetto Random con la seguente istruzione:

Random generatoreRandom = new Random();Una volta che tale oggetto è stato istanziato, si è utilizzato il metodo nextInt(int x) della

classe Random che restituisce un numero casuale compreso nell’intervallo [0, x-1];Consiglio: Conoscere tutti i package è impossibile, però conoscere quelli più usati o

sapere che categoria di classi implementano, può essere utile perché può darsi che quello che vi serve sia gia stato implementato in un package e quindi non dobbiate farlo di sana pianta, con un conseguente notevole risparmio di tempo.

Al termine della lezione proveremo a fare un esercizio che utilizza il package java.util.Random.



9

L’Astrazione

L’astrazione è un meccanismo che permette di concentrarsi sugli aspetti essenziali di una classe o di un metodo (cioè sul suo comportamento e sul modo in cui si interfaccia con il resto del sistema), rinviando l’analisi dei dettagli ad una fase successiva.

Java ha due costrutti per ottenere l’astrazione: le interfacce e le classi astratte.Una classe astratta è una classe che viene progettata soltanto per svolgere la funzione di classe

base, da cui le classi derivate possono ereditare, ma che, da sola, non può essere istanziata.Le classi astratte sono usate anche per rappresentare concetti ed entità astratte, le caratteristiche

"incomplete" della classe astratta vengono condivise da un gruppo di sotto-classi figlie, che vi aggiungono caratteristiche diverse, in modo da colmare le "lacune" della classe base astratta.

Le classi astratte possono essere considerate come super-classi che contengono metodi astratti, progettate in modo che le sotto-classi che ereditano da esse ne "estenderanno" le funzionalità implementandone i metodi. Il comportamento definito da queste classi è "generico" e la maggior parte dei costrutti della classe sono indefiniti e non implementati.

N.B.: Prima che una classe derivata da una classe astratta possa essere istanziata essa ne deve implementare tutti i metodi astratti.



10

L’Astrazione(2)

Per chiarire meglio il concetto di classe astratta consideriamo il seguente caso:



Fino a questo momento abbiamo visto sempre delle sottoclassi che derivano da classi ben definite:

Nell’esempio qui a lato vediamo la rappresentazione grafica di tre classi in relazione tra loro:

Le informazioni in comune tra Studente e Professore sono state inserite nella classe Persona che è un oggetto ben definito anche se preso isolatamente.

11

L’Astrazione(3)

Ci sono casi in cui la classe, da cui derivano le sottoclassi, se presa isolatamente risulta non ben definita: esempio prendiamo una classe Forma da cui derivano la classe Cerchio e Quadrato…

Forma non è un concetto ben definito nella realtà, però lo è se associato alle classi figlie.

In questo caso è possibile creare una classe astratta Forma che definisce i metodi che le classi figlie devono obbligatoriamente implementare…



12

L’Astrazione(4)

In Java una classe astratta si crea utilizzando il modificatore abstract in questo modo:abstract class Forma {

float Perimetro, Area; public float Calcola_Perimetro();public float Calcola_Area();

}

I costruttori vanno necessariamente implementati nelle classi figlie, tramite il meccanismo dell’ereditarietà (ovvero tramite la parola riservata extends):class Quadrato extends Forma {

float lato;public Quadrato(float Lato) { lato = Lato; }

public float Calcola_Perimetro() { Perimetro = lato * 4; }public float Calcola_Area() { Area = lato * lato; }

}



13

Le Interfacce

Una delle linee guida fondamentali nella progettazione OO è la separazione fra l'interfaccia di una classe e la sua implementazione. A tal proposito i progettisti di Java hanno dotato il linguaggio di un costrutto, l'interfaccia appunto, distinto dalla classe. In questo modo si hanno a livello di implementazione due strumenti distinti per definire gli aspetti comportamentali (interfaccia) e quelli implementativi (classe).

Nella prima parte abbiamo visto che fondamentalmente una classe astratta non è altro che una classe in cui i metodi sono senza corpo, infatti nella classe astratta è presente la dichiarazione del metodo seguita dal “;”.

Le interfacce sono classi che possono contenere solamente costanti e metodi d’istanza astratti (quindi non può contenere né costruttori, né variabili statiche, né variabili di istanza, né metodi statici).

Un esempio di interfaccia è la seguente:

public interface Comparable {

public int compareTo(Object o);

}



14

Le Interfacce (2)

Spesso una interfaccia comprende anche una descrizione informale del significato dei metodi (che chiameremo specifica o contratto).

Ad esempio, nella API di Comparable si vede che al metodo compareTo è associata una precisa interpretazione (descritta a parole): esso definisce un ordinamento totale sugli oggetti della classe. Estratto:

“compareTo: Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. [...] The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0. [...] It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). [...]”.

Una classe che voglia implementare l'interfaccia Comparable dovrà definire un metodo compareTo() che conterrà il codice da eseguire.



15

Implementare un Interfaccia

Si può dichiarare che una classe implementa (implements) una data interfaccia: in questo caso la classe deve fornire una realizzazione per tutti i metodi astratti dell'interfaccia, cioè la classe deve fornire metodi con la stessa firma descritta nell'interfaccia (e con il corpo, naturalmente). La realizzazione di un metodo deve anche rispettare la "specifica“ del corrispondente metodo astratto.

Esempio:public class Intero implements Comparable {

int n;[…]public int compareTo(Object o)

{Intero numero = (Intero) o;if (n < numero.n) return -1;else if (n > numero.n) return

1;else return 0;

}[…]

}



16

Una parentesi: Il Casting Esplicito

Ponete l’attenzione su quello meccanismo chiamato cast esplicito:

Il metodo compareTo prende come parametro un Object o che viene subito memorizzato in un oggetto di tipo Intero, ma Object è diverso da Intero!! (Attenzione: Intero è una classe non una variabile di tipo int!!!)

Per ovviare a questo problema chiediamo al sistema di forzare l’oggetto o ad essere di tipo Intero facendo precedere ho dal tipo Intero racchiuso tra parentesi, ovvero effettuiamo un cast esplicito.

In particolare il casting è consentito:

Tra due tipi primitivi (int e float per esempio)

Tra due oggetti legati da un legame di ereditarietà (superclasse e sottoclasse)

Mentre è vietato tra:

Tra un tipo primitivo ed un oggetto

Tra due oggetti senza legame di ereditarietà



17

Una parentesi: Il Casting Esplicito(2)

Il casting può essere implicito o esplicito.Nel primo caso la conversione di tipo viene eseguita automaticamente in quanto si tratta di una operazione sicura. Nel secondo caso è il programmatore che, con cognizione di causa, forza la conversione in quanto potrebbe risultare pericolosa in termini di perdita di dati.

La conversione è sempre sicura quando si converte un tipo di dato che occupa meno spazio in memoria verso un tipo di dato più grande. Potrebbe essere pericolosa quando si converte un tipo di dato che occupa più spazio in memoria verso un altro tipo di dato più piccolo (in questo caso, per far entrare un dato grande in uno più piccolo, occorre necessariamente eliminare la parte in eccesso con conseguenza perdita di dati).

Esempio:

int i; long l; float f; double d;

l = i; // casting implicito (sicuro)d = f; // casting implicito (sicuro)

i = (int) l; // casting esplicitof = (float) d; // casting esplicito

Nel ns. caso Object è un oggetto più grande di Intero pertanto facciamo casting esplicito.



18

I vantaggi delle Interfacce

Alcuni vantaggi che si ottengono nell’usare le interfacce sono i seguenti: La possibilità che l’interfaccia e la sua implementazione siano fatte da due

persone diverse, e questo è molto utile nei progetti di grandi dimensioni, in cui ci sono soggetti che si occupano della struttura complessiva del progetto ed altri soggetti che si occupano dello sviluppo delle singole componenti.

Scrivere programmi generici, evitando di duplicare il codice ( a tal proposito vedremo un altro esempio di interfaccia che forse mi farà comprendere meglio le sue potenzialità)

Definire Tipi di dato astratto.

Vediamo adesso un altro esempio di interfaccia….



19

Interfacce - Esempio

Prendiamo la seguente interfaccia:public interface OggettoPrezzato {

public void ImpostaPrezzo(double Prezzo); public double RestituisciPrezzo();

}

L'interfaccia OggettoPrezzato definisce il comportamento di un articolo con prezzo. Possiamo a questo punto implementare l'interfaccia in una classe applicativa Libro nel modo seguente:

public class Libro implements OggettoPrezzato { private String titolo; private String autore; private double prezzo; ... public void ImpostaPrezzo(double prezzo) { this.prezzo = prezzo; }

public double RestituisciPrezzo() { return prezzo; } }



20

Interfacce – Esempio (2)

In una nostra classe possiamo sviluppare il metodo TotaleAcquisti in questo modo:double TotaleAcquisti(Collection items)

{

Iterator it = items.iterator();

OggettoPrezzato item;

double Totale = 0;

while (it.hasNext())

{

item = (OggettoPrezzato)it.next();

Totale += item.RestituisciPrezzo(); } return Totale;

}

Quindi semplicemente, dato una collezione di oggetti, il nostro metodo non fa altro che calcolarne la somma dei prezzi degli oggetti che compongono tale collezione.



Una Collection non è altro che una collezione di oggetti omogenei, mentre un Iterator è un iteratore, ovvero un puntatore che ci permette di scorrere la collazione…

Ne riparleremo…

21

Interfacce – Esempio (3)

Supponiamo ora di voler estendere l'applicazione per gestire non solo libri ma anche CD musicali. Introdurremo a questo proposito una nuova classe che implementa l'interfaccia OggettiPrezzati:

public class CD implements OggettiPrezzati{

private String titolo; private String cantante; private Collection canzoni; private double prezzo; ....

public void ImpostaPrezzo(double prezzo) { this.prezzo =

prezzo; } public double RestituisciPrezzo() { return prezzo; }

}

Il codice precedente per il calcolo del prezzo totale funziona senza modifiche anche se la collezione contiene oggetti di classe CD perché tale codice fa riferimento all'interfaccia e non alla classe concreta.



Date post:	02-May-2015
Category:	Documents
Upload:	rossella-cappelli
View:	232 times
Download:	0 times

Lezione n° 10 Istituto Statale di Istruzione Superiore “F. Enriques” Corso JAVA.

Documents