Pagina Iniziale | Preferiti Comunity: Login | Registrati | Newsletter | Forum | Concorsi Newsgroup
Canali: Hardware | Software | Files | Webmaster | Cellulari | Shop
Nel sito: News | Articoli | Files | Manuali | Consigli PC | Schede cellulari | Programmaz. | Hosting | Motori Ricerca | Glossario | Link
Servizi: Shopping | Forum | Crea un BLOG | Cartucce Compatibili | Tool News |   Sponsor: Automazione Industriale
  Articoli

Recensioni
Consigli per PC


  News e files

Software
Telefonia
Internet
Tecnologia
Files e Download


  Manualistica

Guide HW/SW
Scripts ASP
Scripts HTML
Scripts Java
Scripts Delphi
Glossario


  Shopping

Hardware
Software e Giochi
Elettronica
Cinema e Film
Console e Accessori
Prodotti Ufficio
Formazione e Corsi

Tieniti aggiornato sul mondo della tecnologia con la nostra newsletter!
La tecnologia sulla tua
casella e-mail

[Info Newsletter]


Concessionaria Pubblicitaria

<< News Precedente [Fine Pagina] News Successiva >>
Il linguaggio Java: lez.8

Un articolo di: Fonte Esterna del 14/01/2003      Letture: 11121
Vai alla pagina:
 1 - Unità didattica 7.1, 7.2 e 7.3.a )

Si ringrazia Claudio De Sio per la concessione del materiale pubblicato in questo articolo.

Un esempio guidato alla programmazione ad oggetti

Obiettivi:

Il Lettore al termine di questo capitolo dovrà essere in grado di

Sviluppare un’applicazione in Java, utilizzando i paradigmi della programmazione ad oggetti (unità 7.1, 7.2).

Unità didattica 7.1)

- Perché questo modulo:
Questo modulo è stato introdotto, per dare al lettore una piccola ma importante esperienza, finalizzata alla corretta utilizzazione dei paradigmi della programmazione ad oggetti. Quando si approccia all’object orientation, l’obiettivo più difficile da raggiungere, non è comprenderne le definizioni, che, come abbiamo visto, sono derivate dal mondo reale, ma, piuttosto, apprendere il corretto utilizzo di esse all’interno di un’applicazione. Ciò che sicuramente sembra mancare al lettore, è la capacità di scrivere un programma, che sicuramente non è cosa secondaria. Facciamo un esempio: se venisse richiesto di scrivere un’applicazione che simuli una rubrica, o un gioco di carte, od un’altra qualsiasi applicazione, il lettore si porrà ben presto alcune domande: "quali saranno le classi che faranno parte dell’applicazione?", "dove utilizzare l’ereditarietà", "dove utilizzare il polimorfismo", e così via. Sono domande cui è molto difficile rispondere, perché, per ognuna di esse, esistono tante risposte che sembrano tutte valide. Per esempio, se dovessimo decidere quali classi comporranno l’applicazione che simuli una rubrica, potremmo decidere di codificare tre classi (Rubrica, Persona, e classe che contiene il main), oppure 5 classi (Indirizzo, Ricerca, Rubrica, Persona, e classe che contiene il main). Riflessioni approfondite sulle varie situazioni che si potrebbero presentare nell’utilizzare quest’applicazione (casi d’uso), probabilmente consiglierebbero la codifica di altre classi. Una soluzione con molte classi sarebbe probabilmente più funzionale, ma richiederebbe troppo sforzo implementativo per un’applicazione definibile "semplice". D’altronde, un’implementazione che fa uso di un numero ridotto di classi, costringerebbe lo sviluppatore, ad inserire troppo codice in troppo poche classi. Inoltre, ciò garantirebbe in misura minore l’utilizzo dei paradigmi della programmazione ad oggetti, giacché la nostra applicazione, più che simulare la realtà, cercherà di "arrangiarla". La soluzione migliore sarà assolutamente personale, perché garantita dal buon senso e dall’esperienza. È già stato accennato che un importante supporto alla risoluzione di tali problemi, è garantito dalla conoscenza di metodologie object oriented, o, almeno dalla conoscenza di U.M.L.. In questa sede però, dove il nostro obbiettivo principale è quello di apprendere un linguaggio di programmazione, non è consigliabile, né fattibile, introdurre anche altri argomenti tanto complessi. Sarà presentato invece un esercizio-esempio, che il lettore può provare a risolvere, oppure direttamente leggerne la soluzione presentata. Con quest’esercizio ci poniamo lo scopo di operare delle attente osservazioni sulle scelte fatte, per poi andare a trarre delle conclusioni importanti. Inoltre, la soluzione sarà presentata, con una filosofia iterativa ed incrementale, così com’è stata creata, sul modello delle moderne metodologie orientate agli oggetti. In questo modo, saranno esposti al lettore tutti i passaggi eseguiti, per arrivare alla soluzione.

Unità didattica 7.2)

- Esercizio 7.a)

N.B.: con quest’esercizio non realizzeremo un’applicazione utile, lo scopo è puramente didattico.

Obiettivo:

Realizzare un‘applicazione che possa calcolare la distanza geometrica tra punti. I punti possono trovarsi su riferimenti a due o tre dimensioni.

Unità didattica 7.3)

- Risoluzione dell’esercizio 7.a)

Di seguito è presentata una delle tante possibili soluzioni. Non bisogna considerarla come una soluzione da imitare, ma piuttosto come elemento di studio e riflessione per applicazioni future.
- Passo 1:

Individuiamo le classi di cui sicuramente l’applicazione non può fare a meno. Sembra evidente che componenti essenziali debbano essere le classi che devono costituire il "modello" di quest’applicazione. Codifichiamo le classi Punto e Punto3D sfruttando incapsulamento, ereditarietà, overload di costruttori, e riutilizzo del codice:

class Punto { private int x, y; public Punto() { //Costruttore senza parametri } public Punto(int x, int y) { this.setXY(x, y); //Il this è facoltativo //riutilizziamo codice } public void setX(int x) { this.x=x; //Il this è facoltativo } public void setY(int y) { this.y=y; //Il this è facoltativo } public void setXY(int x, int y) { this.setX(x); //Il this è facoltativo this.setY(y); } public int getX() { return this.x; //Il this è facoltativo } public int getY() { return this.y; //Il this è facoltativo } } class Punto3D extends Punto { private int z; public Punto3D() { //Costruttore senza parametri } public Punto3D(int x, int y, int z) { this.setXYZ(x, y, z); //Il this è facoltativo //riutilizziamo codice } public void setZ(int z) { this.z=z; //Il this è facoltativo } public void setXYZ(int x, int y, int z) { this.setXY(x, y); //Il this è facoltativo this.setZ(z); } public int getZ() { return this.z; //Il this è facoltativo } }

N.B.: notiamo che pur di utilizzare l’ereditarietà "legalmente", abbiamo violato la regola dell’astrazione. Infatti, abbiamo assegnato l’identificatore Punto ad una classe che si sarebbe dovuta chiamare Punto2D. Ricordiamo che per implementare il meccanismo dell’ereditarietà, lo sviluppatore deve testarne la validità, mediante la cosiddetta "is a" relationship (la relazione "è un"). Violando l’astrazione abbiamo potuto validare l’ereditarietà: ci siamo infatti chiesti: "un punto a tre dimensioni è un punto?". La risposta affermativa ci ha consentito la specializzazione. Se avessimo rispettato la regola dell’astrazione non avremmo potuto implementare l’ereditarietà tra queste classi, dal momento che, ci saremmo dovuti chiedere: "un punto a tre dimensioni è un punto a due dimensioni?". In questo caso la risposta sarebbe stata negativa. Questa scelta è stata fatta non perché ci faciliti il prosieguo dell’applicazione, anzi, proprio per osservare che in un’applicazione che subisce degli incrementi, il "violare le regole" porta a conseguenze negative. Nonostante tutto, la semplicità del problema e la potenza del linguaggio, ci consentiranno di portare a termine il nostro compito. Contemporaneamente vedremo quindi come forzare il nostro codice affinché soddisfi i requisiti.

N.B.: la codifica di due classi come queste è stata ottenuta apportando diverse modifiche. Il lettore non immagini di ottenere soluzioni ottimali al primo tentativo! Questa osservazione varrà anche relativamente alle codifiche realizzate nei prossimi passi.

- Passo 2:

Individuiamo le funzionalità del sistema. È stato richiesto che la nostra applicazione debba in qualche modo calcolare la distanza tra due punti. Facciamo alcune riflessioni prima di "buttarci sul codice". Distinguiamo due tipi di calcolo della distanza tra due punti: tra due punti bidimensionali, e tra due punti tridimensionali. Escludiamo a priori la possibilità di calcolare la distanza tra due punti, di cui uno è bidimensionale e l’altro e tridimensionale. A questo punto sembra sensato introdurre una nuova classe che abbia la responsabilità di eseguire questi due tipi di calcoli. Nonostante questa appaia la soluzione più giusta, optiamo per un’altra strategia implementativa: assegniamo alle stesse classi Punto e Punto3D la responsabilità di calcolare le distanze relative ai "propri" oggetti. Notiamo che l’astrarre queste classi inserendo nelle loro definizioni dei metodi chiamati dammiDistanza(), rappresenta una palese violazione alla regola dell’astrazione stessa. Infatti, in questo modo potremmo affermare che intendiamo un oggetto come un punto, come capace di "calcolarsi da solo" la distanza geometrica che lo separa da un altro punto. E tutto ciò non rappresenta affatto una situazione reale.

Quest’ulteriore violazione dell’astrazione di queste classi, ci permetterà di valutarne le conseguenze, e, contemporaneamente, di verificare la potenza e la coerenza della programmazione ad oggetti.

N.B.: la distanza geometrica tra due punti a due dimensioni, è data dalla radice della somma del quadrato della differenza tra la prima coordinata del primo punto e la prima coordinata del secondo punto, e del quadrato della differenza tra la seconda coordinata del primo punto e la seconda coordinata del secondo punto.

Di seguito è presentata la nuova codifica della classe Punto, che dovrebbe poi essere estesa dalla classe Punto3D:

class Punto { private int x, y; . . . //inutile riscrivere l’intera classe public double dammiDistanza(Punto p) { int tmp1=(x-p.x)*(x-p.x); //quadrato della differenza della x dei due punti int tmp2=(y-p.y)*(y-p.y); //quadrato della differenza della y dei due punti return Math.sqrt(tmp1+tmp2); //radice quadrata della somma dei due quadrati } }


Notiamo come in un eventuale metodo main sarebbe possibile scrivere il seguente frammento codice:

Punto p1 = new Punto(5,6); Punto p2 = new Punto(10,20); System.out.println("distanza è" +p1.dammiDistanza(p2));

Vai alla pagina:

Elenco delle pagine di "Il linguaggio Java: lez.8"

Unità didattica 7.1, 7.2 e 7.3.a ) - Pagina 1
Unità didattica 7.3.b) - Pagina 2



[Indietro]    [Su]      [Home]      [Commenti]      [V. Stampabile]

Commento di Anonimo (ip: 213.140.6.100), scritto il 25/05/2005 alle 22:02:12
Sinceramente...il codice incolonnato così non'è per niente chiaro.
non potreste allinearloa sinistra???

Commento di Samuel Zilli, scritto il 26/05/2005 alle 11:48:56
Corretto il problema. Era dovuto ad un errata re-impaginazione. Grazie della segnalazione.

Commento di Anonimo (ip: 213.121.209.14), scritto il 26/02/2006 alle 16:28:20
public void setY(int y)
{
this.y=y; //Il this è facoltativo
}

Direi che in questo caso il riferimento implicito è d'obbligo visto che c'è un omonimia tra l'attributi y e il parametro y :)

Commenta questa notizia:
Non hai ancora fatto il
Login, puoi inserire commenti solo come anonimo.
ATTENZIONE: il tuo IP verrà memorizzato e mostrato a fianco del commento; con la pressione del tasto invia commento si esprime il consenso alla pubblicazione di tale informazione personale.
A discrezione dello staff, i commenti ritenuti non adatti od offensivi potranno essere rimossi. Nel caso di utilizzo di espressioni volgari od offensive il comportamento verrà segnalato al provider interessato.
Se non ti sei ancora registrato, cosa aspetti? Registrati subito.

Da ora puoi discutere dei problemi informatici anche sul nostro FORUM

Testo del commento:


  News correlate
 Corso Java @ilsoftware.it
 Il linguaggio Java: lez.10/10
 Il linguaggio Java: lez.9
 Il linguaggio Java: lez.8
 Il linguaggio Java: lez.7
 Il linguaggio Java: lez.6
 Il linguaggio Java: lez.5
 Il linguaggio Java: lez.4
  Ultime dal Forum

thesis disable comments on some pages
??????? Diult Diult Diult
essay on should we keep pets at home
writing an essay for college admissions
ib business and management past papers 2014
Zolpidem 5 mg APO ZOL 5
depression era essay
obstacles i overcame to attend college essay
russian march revolution essay

Comunicazioni / Note Legali / Staff / Collabora / Pubblicità / Privacy / Contatti


Triboo Media s.r.l. (società socio unico) - Viale Sarca 336 - Edificio 16, 20126 Milano (MI) Cap. Soc. 1.250.000,00 euro i.v. - P.IVA, C.F. e CCIAA di Milano IT06933670967 - REA MI-1924178 tel. +39 02 64741470 - fax +39 02 64741494 Società sottoposta alla direzione e coordinamento di TRIBOO SPA - all rights reserved CAP. SOC. EURO 28.740.210 I.V. - P.IVA 02387250307 - COD. FISC. e numero iscrizione al registro delle imprese CCIAA MI : 02387250307 tel.+39 02 64741401 - fax + 39 02 64741491. Utenti Connessi: 258


Pagina creata in 0,12sec. Powered by JuiceADV S.r.l.

Stats v0.1 (0,000sec.)