Che cos’è la complessità?

(tratto da complexityexplorer.org)

tunnel-formiche

Colonia di formiche che costruisce un tunnel Autore: Mehmet Karatay https://commons.wikimedia.org/wiki/File:Safari_ants_tunnel.jpg

Un primo esempio di sistema complesso è il formicaio. La formica – presa nella sua singolarità – è un animale poco complesso: se prendiamo, ad es., solo un centinaio di formiche, queste si muoveranno in circoli senza senso fino alla morte. Se prendiamo in considerazione un numero molto più grande di formiche, invece, cambia tutto. Ad es. possiamo pensare ad una colonia di formiche che costruisce un tunnel. Ciascuna formica, in sé, è semplice, ma la colonia, nella sua globalità, lavora in modo cooperativo per realizzare compiti molto complessi, senza un controllo centrale, cioè senza che ci sia una formica o un gruppo di formiche che assumono il comando. In altre parole il formicaio si organizza per produrre strutture molto più complicate di quelle che può produrre una singola formica. Questa foto mostra le formiche che costruiscono un ponte con i loro corpi in modo che altri membri della colonia di formiche possa attraversarlo per passare da una foglia all’altra.

ponte-formiche

Colonia di formiche che si organizza per costruire un passaggio tra due foglie Autori: C. Anderson, G. Theraulaz, J.-L. Deneubourg

Il video presentato nella sottosezione 1.1 del corso mostra le formiche che formano un ponte di questo tipo da un bastoncino a terra. Potete vedere che si aggiungono in modo graduale alla struttura. Ciascuna formica secerne sostanze chimiche per comunicare con le altre formiche, e il ponte è realizzato senza nessun controllo centrale. Questo tipo di sistema è denominato “sistema decentralizzato auto-organizzato“.

180px-Termite_mound_NT

Struttura costruita dalle termiti. Autore: Ian Armstrong https://commons.wikimedia.org/wiki/File:Termite_mound_NT.jpg

Ci sono altri insetti sociali che hanno comportamenti simili. Ad es. le termiti, che costruiscono strutture in cui vivono estremamente complesse (vedi foto). Una delle problematiche di maggior rilievo nei sistemi complessi è capire come semplici agenti individuali possono avere nell’insieme comportamenti complessi senza un controllo centrale. Possiamo comunque pensare a moltissimi altri esempi di sistemi complessi, in altri campi diversi da quelli degli insetti: ad es. il cervello, in cui gli agenti individuali sono i neuroni. Il cervello umano è composto da 100 miliardi di neuroni e 100.000 miliardi di connessioni tra loro. Ciascun neurone è relativamente semplice se confrontato con l’intero cervello e, anche in questo caso, non c’è un controllo centrale. In qualche modo, l’insieme di neuroni e connessioni dà  luogo a comportamenti complessi che chiamiamo”cognizione”, “intelligenza” o persino “creatività”. L’osservazione del cervello  ha mostrato che i neuroni sono organizzati in diverse aree funzionali. Allo stesso modo delle formiche e delle termiti, i neuroni si sanno organizzare in strutture complesse che permettono la vita e la sopravvivenza.

Un altro sistema complesso è il sistema immunitario. e’ distribuito nel corpo, comprende diversi organi, come si vede nell’immagine, e milioni di cellule, muovendosi nel circolo sanguigno e nel sistema linfatico, difendono il corpo dalle malattie. Le cellule, ad es., possono attaccare una cellula cancerosa. Come le formiche, le cellule del sistema immunitario comunicano tra loro per mezzo di segnali chimici, e lavorano insieme senza un controllo centrale, per lanciare attacchi coordinati verso quello che percepiscono come una minaccia per il corpo. Inoltre, la popolazione delle cellule sel sistema immunitario si modifica, o si adatta, in base all’ambiente circostante che viene percepito. Questo tipo di adattamento è un’altra tipica caratteristica dei sistemi complessi.

Un altro esempio di sistema complesso è il genoma umano. Ciascun cromosoma è composto da migliaia di geni. I geni sono catene di DNA che percorrono l’intero cromosoma. Si pensa che il genoma umano possieda circa 25.000 geni. In termini di sistema complesso, si può pensare ai geni come sistemi semplici, che interagiscono tra loro in modo decentralizzato. I geni interagiscono controllando vicendevolmente la formulazione, cioè la trasformazione in proteine.

Rete regolatoria genetica

Qui è rappresentata una piccola rete genetica regolatoria mappata dai ricercatori.  Ciascun ovale o rettangolo rappresenta un gene  e le frcce rappresoentano il legame da controllore a controllato.  Si è scoperto che il genoma umano è fatto di migliaia di reti come questa, in cui i geni interagiscono in modi complicati, ed è l’interazione che rende il sistema complesso.

Esempio di catena alimentare.

L’idea di rete è fondamentale nello studio della complessità in natura. Un altro tipo di rete è, ad esempio, la catena alimentare. Ciascun nodo è un particolare gruppo di specie, e le frecce rappresentano chi mangia chi. Se una specie punta un’altra, significa che il primo è cibo per il secondo. Per esempio, in questa catena alimentare dell’Alaska, le volpi sono all’apice, poiché mangiano parecchi tipi di animali ma non sono mangiati da nessuno, almeno in questo schema.

Astrazione della catena alimentare, tratto dal sito http://www.afsc.noaa.gov/Quarterly/jas2006/jasfeaturelead.htm

Abbiamo anche schemi astratti della catena alimentare, come questo. Un altro tipo di rete è la rete sociale, in cui i nodi rappresentano le persone e i collegamenti rappresentano l’amicizia. Gli studiosi dei sistemi complessi sono molto interessati allo studio di reti di grandi dimensioni, come Facebook, per capire la struttura, come si formano, come si modificano, come vengono trasmesse le informazioni, ecc.

Le economie sono altri sistemi complessi in cui l’interazione è fondamentale (nodi = istituzioni, link = relazioni tra queste, ad es. se una banca possiede un’altra banca). La quantità di connessioni influisce sulla stabilità. Il campo interdisciplinare dello stidio delle reti, che nacque dalla comunità di ricercatori di sistemi complessi, studia questo tipo di fenomeni per le reti nelle più disparate discipline.

Altro esempio: la città è un sistema complesso.  SI è spesso detto che la città è in molti versi un organismo vivente, ma in che modo sono strutturate, crescono, operano?

Proprietà dei sistemi complessi

  • agenti semplici (rispetto al sistema)
  • interazioni non lineari
  • mancanza di controllo centrale
  • Comportamenti emergenti:
    organizzazione gerarchica
    elaborazione delle informazioni
    dinamici
    si evolvono e imparano.

Studio e discipline dei sistemi complessi

Dinamicità: studio della modifica della struttura e del comportamento

Informazioni: studio della rappresentazione, dei simboli e della comunicazione

Elaborazione: studio della elaborazione e dei processi delle informazioni e della risposta

Evoluzione: adattamento ai cambiamenti dell’ambiente

Obiettivi:

  1. unire le precedenti discipline per costituire uno studio interdisciplinare dei sistemi complessi (ad es. lo studio del comportamento delle formiche nell’organizzazione di una colonia può essere comparato ad alcuni comportamenti propri degli agglomerati urbani, oppure le reti neuronali del cervello a un sistema economico?). A tutt’oggi, gli sviluppi di questa scienza interdisciplinare costituisce il risultato più importante della scienza dei sistemi complessi.
  2. lo sviluppo di una teoria generale della complessità.

Metodologie:

  1. sperimentazione
  2. teoria
  3. simulazione (tramite computer)

Definizione di complessità

Seth Lloyd (2001) – Measure of complexity: a nonexahustive list (IEEE Control System Magazine) elenca 42 differenti definizioni per la misurazione della complessità, in realtà per misurare differenti aspetti della complessità. Noi tratteremo la definizione di Informazione di Shannon e di Dimensione Frattale.

Un altro importante articolo è Warren Weaver, Science and Complexity (1948). Weaver distinse i problemi scientifici in tre categorie: problemi semplici (con due, tre o poche variabili, come pressione, temperatura, corrente, resistenza, voltaggio, popolazione); problemi di complessità disorganizzata (con milioni o miliardi di variabili, come ad es. in meccanica statistica, per comprendere grandezze come la temperatura che deriva dal movimento di molecole), in cui le interazioni tra variabili sono poche; problemi di complessità organizzata, in cui sono presenti interazioni forti e non lineari tra le variabili, problemi in cui si ha a che fare con un certo numero di fattori interconnessi in un organismo.

Lesson 16 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=tRwVX7-DWY4&index=16&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv

Per il momento, le classi create sono state utilizzate solo per fare girare JUnit Test. In questa lezione creeremo un programma standalone che usa le classi per gestire un oggetto di tipo MyLibrary.

Dobbiamo creare un metodo speciale “main” in una classe. Il JRE (Java Runtime Engine) carica le classi e poi esegue questo metodo.  Potremmo sfruttare una GUI (Graphical User Interface) per fornire un form da compilare, ma non è negli obiettivi del corso. Invece creeremo un metodo main che simula le operazioni effettuate da un utente e mostra a video i risultati.

Per creare un programma Java standalone useremo il wizard Eclipse Export –> otterremo un .jar eseguibile su qualsiasi computer compatibile. Possiamo creare i metodo main in una classe qualsiasi, noi lo mettiamo nella MyLibrary(). Scrivendo main e usando il suggerimento, otteniamo public static void main(String[] args) , un metodo che permette di leggere i parametri come una variabile di tipo String[] di nome args da riga comandi. Nel nostro caso, comunque, non ci sarà nessun input da riga comandi.

Iniziamo creando una nuova MyLibrary() e chiamandola “Test Drive Library”. Creiamo alcuni libri e settiamo gli autori, creiamo alcune persone e settiamo i nomi.

TIP: per scrivere una linea println possiamo prima scrivere la stringa da visualizzare, poi selezionarla e CTRL+SPACE+UP ARROW (nel mio caso TAB + UP ARROW) , Eclipse aggiunge il comando in automatico. Nel nostro caso scriviamo System.out.println(“Just created new library”); poi invochiamo un nuovo metodo che fra un po’ implementeremo: testLibrary.printStatus();

Scriviamo una stringa per la stampa di “Check out War and Peace to Sue”, la corrispondente operazione di checkOut e di nuovo printStatus().

Scriviamo una stringa per la stampa di “Do some stuff”, il check in di b1, il check out di b2 a jim e di nuovo printStatus().

Ora usiamo il quick fix per creare il metodo printStatus(), sempre nella classe MyLibrary. In questo metodo mettiamo una prima linea di stampa “Status Report of MyLibrary \n” +this.toString(). NOTE: \n in una stringa permette di andare a capo, inoltre dentro a println si può omettere il metodo toString(), in questo caso basterebbe scrivere this.

Facciamo un ciclo for sui libri per stamparli, e un ciclo sulle persone per vedere quanti libri possono avere in prestito e quanti ne hanno effettivamente. Poi vogliamo i libri disponibili e una stringa finale di fine report (vedi codice).

Possiamo far girare la classe MyLibrary come java application, perché la MyLibrary possiede il metodo main. Quindi: Run > Run as > Java Application. Attenzione: come mai non vengono visualizzate coerentemente le informazioni? Perché quando abbiamo creato i libri e le persone ci siamo dimenticati di aggiungerli alla library. Correggiamo invocando i metodi addBook e addPerson (vedi codice). Di nuovo Run > Run as > Java Application –> adesso il report è coerente con le operazioni effettuate.

Per il momento abbiamo fatto girare il tutto su Eclipse.  Ora creiamo un programma standalone che possiamo eseguire fuori da Eclipse, su ogni sistema Java compatibile. Selezioniamo File > Export > Java JAR per creare una versione eseguibile. Nella finestra che si propone possiamo selezionare le risorse da esportare. E’ per questo che abbiamo salvato i test in una cartella diversa da src, così la possiamo escludere. Dobbiamo dare un nome al programma e scegliere dove salvarlo. Facendo next, si propone la finestra in cui bisogna selezionare (anche tramite il pulsante Browse) quale classe ha il metodo main. Nel nostro caso ce n’è solo una, quindi la selezioniamo e completiamo la creazione.

Per far girare questo programma, aprire il terminale, andare nella dir in cui è stato salvato, e dare il comando: java -jar nomeprogramma.jar .

CONGRATULATION!!!

Per approfondimenti, vedere le risorse indicate dal  Tutorial Companion Guide.

Lesson 15 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=kmMRGlEL0ws&index=15&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv

Continuiamo con i metodi che avevamo definito nelle specifiche. getAvailableBooks() ritorna la lista dei libri che non sono in prestito. Come al solito, scriviamo il testGetAvailableBooks() con le specifiche. Quindi mettiamo setup() e addItems() per creare un ambiente, poi creiamo una ArrayList<Book> testBooks = new ArrayList<Book>(); possiamo creare subito il getAvailableBooks() vuoto con il quick fix e andare avanti e indietro tra oggetto e test. Facciamo delle verifiche sulla lunghezza e sugli indici di questa lista di libri disponibili (vedi codice); poi facciamo un checkOut, settiamo di nuovo il testBook e di nuovo controlli di lunghezza e indici; e di nuovo per il secondo libro (vedi codice).

Ora possiamo scrivere il codice di getAvailableBooks(): creiamo una lista di libri che chiamiamo result, facciamo un ciclo for per controllare su tutti i libri della biblioteca se il campo person è null, nel qual caso si aggiunge a result. Alla fine, fuori dal loop, return result. Facciamo la verifica e funziona!

Altro metodo: getUnavailableBooks(). E molto simile al precedente. I controlli si aspetteranno inizialmente una lista vuota, poi, ad ogni checkOut, si riempirà. Creiamo poi il metodo con il quick fix, e copiamo il codice del metodo precedente modificando == in != nell’if. Facciamo il run JUnit ed è OK!

GLi ultimi metodi dono i toString() per Book() e MyLibrary(), perché per Person() lo avevamo già fatto.

Il toString di Book() deve ritornare il titolo, l’autore, il nome della persona a cui è in prestito oppure la scritta available (vedi codice).

Il toSTring di MyLibrary non può ritornare tutto l’elenco, perché potrebbe essere troppo lungo, contenendo centinaia o migliaia di libri e persone. Deve ritornare informazioni riassuntive (vedi codice.

I test passano. La prossima lezione vedremo come utilizzare le classi che abbiamo implementato in un programma Java.

Lesso 14 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=jEb8HfrMx4Q&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv&index=14

Continuiamo con getBooksForPerson(). Prima di tutto creiamo una ArrayList<Book> che chiamiamo result. Sarà la lista che sarà ritornata dal metodo.  Poi usiamo un loop di tipo for per analizzare tutti i libri della biblioteca, per vedere quelli che sono stati prestati alla persona. Selezioniamo foreach dai suggerimenti di Eclipse e scriviamo for (Book abook : this.getBooks) dove aBook è il nome della variabile locale e this.getBooks è la lista di tutti i libri della biblioteca. Questo significa fare il foreach per ogni aBook in this.getBooks().

Se il libro è in prestito (cioè se il campo person del libro non è null) e se il nome del campo person è uguale al nome di p1, allora dobbiamo aggiungere il libro alla lista. Per fare questo mettiamo un ciclo if (vedi codice).  Alla fine return result, attenzione a metterlo fuori dal loop. Dato che abbiamo due condizioni di if, abbiamo introdotto &&, che è l’END logico.

NOTA: abbiamo usato .equals() come metodo di confronto. Infatti questo è il metodo di confronto di oggetti, e le stringhe sono oggetti. Il == si usa solo per primitive, come int, double, char, boolean).

Se facciamo il run JUnit del test, naturalmente il testCheckOut fallisce, perché non lo abbiamo ancora completato, però il testGetBooksForPerson() sì.  Osservazione: perché dobbiamo fare, nel loop for, il controllo che non sia null? Se togliamo questo controllo abbiamo un errore di runtime (nullPointerException). Questo si verifica ogni volta che tentiamo di eseguire un metodo su un oggetto null.

Adesso possiamo completare il metodo checkOut(). Definiamo la variabile locale di tipo int bookOut = this.getBooksForPerson(p1); è il numero di libri che p1 ha in prestito. Per rendere il codice più leggibile, poiché dobbiamo aggiungere una condizione nell’if, mettiamo la doppia parentesi e aggiungiamo && (bookOut < p1.getMaximumBooks()).  Facciamo il rerun e funziona!

Aggiungiamo questo test alla suit, aggiungendo in AllTest la riga suite.addTestSuite(MyLibraryTest.class); . E funziona!

Lesson 13 – Java for Beginners

Vedere video https://www.youtube.com/watch?v=z9Zm69wod1I&index=13&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv

TIP per controllare se le parentesi sono aperte e chiuse correttamente: posizionarsi a destra di { --> viene evidenziata la } corrispondente; posizionarsi a destra di } e fare CTRL (cmd per mac) +shift+p --> il cursore si sposta alla corrispondente {.

Dobbiamo aggiungere una specificacheckOut e checkIn, perché ci siamo dimenticati di maximumNumber: non possiamo prestare libri a una persona che ha già raggiunto il massimo numero di libri ammessi. Quindi continuiamo con il testCheckOut. Dobbiamo riscrivere setup(), mettere per semplicità p1.setMaximumBooks(1) e di nuovo assegnare gli elementi b1, b2, p1 e p2 alla ml. Poiché questa parte di codice era già scritta, per non riscriverla la trasformiamo in metodo mediante Refactor > Extract Method… e chiamandolo addItems(). In automatico, Eclipse scrive le righe selezionate come nuovo metodo e sostituisce alle righe, ogni volta che le trova nel codice (anche con righe vuote in mezzo) la call al metodo. Continuiamo poi facendo i controlli della specifica che vogliamo aggiungere: il check out del primo libro deve essere true, mentre del secondo deve essere false (perché la persona ha raggiunto il massimo numero di libri che può prendere in prestito). Facendo il run JUnit del test, questo ovviamente fallisce, perché dobbiamo far sì che il checkOut confronti il maximumNumber della persona con il numero dei libri assegnati.  Per far questo ci occorre il metodo (già pensato come specifica) che ritorna la lista dei libri prestati a una persona:  getBooksForPerson(p).

Per scriverlo, come al solito partiamo dal test continuando  testGetBooksForPerson(). Iniziamo con setup() e addItems(). Vogliamo fare il test iniziale dei libri assegnati, quindi: assertEquals(0, ml.GetBooksForPersons(p1));. Poi assegnamo un libro: ml.checkOut(b1, p1);   per comodità creiamo la lista dei libri prestati a p1: ArrayList<Book> testBooks = ml.getBooksForPerson(p1); e controlliamo la lunghezza e gli indici: assertEquals(1,testBooks.size()); assertEquals(0,testBook.indexOf(b1); . Assegnamo un altro libro e facciamo gli opportuni controlli (vedi codice). Poi, con il quick fix, creiamo il metodo getBooksForPerson() vuoto. Nella prossima lezione lo completeremo.

Lesson 12 – Java for Beginners

Vedere video https://www.youtube.com/watch?v=58vtylcMOFo&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv&index=12

Continuiamo a scrivere i metodi considerando la specifica 4 su checkOut e checkIn. Scriveremo il test che controlla entrambi. Specifiche delle operazioni di prestito e restituzione:

  • legare un oggetto Person() ad un oggetto Book() inserendo nel campo person  della classe Book() tale oggetto Person() . Utilizzeremo quindi il metodo setPerson di Book()
  • gestire il caso in cui il libro è già in prestito. Possiamo controllare questo vedendo se il campo person è pieno o vuoto.
  • Il metodo potrebbe essere eseguito e fallire a causa di questo, avvertire in caso di fail.

Pseudo code:

  1. controlla che this book non sia in prestito
  2. se non è in prestito, setta il campo person del book al valore this person e fai sapere che il metodo ha avuto successo
  3. altrimenti fai sapere che il metodo ha fallito.

Per far sapere se il metodo ha avuto successo o ha fallito si fa ritornare il boolean true o false (quindi il metodo ritorna un boolean). Dobbiamo inoltre sapere che cosa significa this book e this person, quindi li passeremo come parametri del metodo (sarà public boolean checkOut(Book b, Person p) , però noi come al solito iniziamo dal test).

Il metodo testCheckOut deve iniziare con setup() poi aggiungeremo libri e persone alla libreria ml (vedi codice).

Impostiamo poi un controllo per la riga di fail: assertTrue(“Book did not check out correctly”, ml.checkOut(b1,p1). Infatti ml.checkOut(b1,p1) ritornerà un boolean. Facciamo anche il controllo della persona a cui è stato prestato il libro: assertEquals(“Fred”, b1.getPerson.getName()) . Facciamo anche i seguenti controlli (vedi codice):

  • per il checkOut:
    • il libro è già in prestito
    • la restituzione fallisce
  • per il checkIn:
    • il libro è già stato restituito
    • il libro non è mai stato prestato.

Con il quick fix creiamo i metodi checkOut e checkIn nella classe MyLibrary(), poi scriviamo il codice. Per il checkOut ricordiamo che checkOut(b1,p1) deve settare b1.setPerson(p1), ma SOLO se il campo b1.getPerson() è vuoto. Usiamo alcuni nuovi comandi (vedi codice) : condizione if ; == , != , null. Analogamente per checkIn (vedi codice).

Lesson 11 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=CzE84s0W2ic&index=11&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv

Aggiungiamo altri metodi alla MyLibrary, sempre con il Test First Approach.

Ecco cosa vogliamo:

  1. i getters per i campi (i setters non servono, perché i campi vengono settati quando creiamo gli oggetti;
  2. addBook, addPerson (metodi per aggiungere oggetti alla libreria)
  3. removeBook, removePerson (metodi per elimiare oggetti)
  4. checkOutBook, checkInBook (prestito e restituzione)
  5. getAvailableBooks
  6. getBooksForPerson

1 Lo facciamo in automatico. Source > Generate Getters and Setters > spuntiamo i tre getters. Lanciamo di nuovo il test per essere sicuri che vada tutto bene;

2 e 3 Abbiamo bisogno di creare alcuni oggetti da gestire, quindi creiamo un metodo setup() a posta per creare queste istanze senza fare duplicati (vedi codice). Attenzione: quando li creiamo sono variabili locali, quindi, una per volta, selezioniamo le dichiarazioni e Refactor > Convert Local Variable to Field. Ora le variabili sono disponibili per il test. Siamo pronti per creare testAddBook, in cui richiamiamo setup(). Facciamo alcune verifiche dell’addBook (ancora da creare) aggiungendo libri e  removeBook (ancora da creare) togliendo libri e testando la size e gli indici (vedi codice). Con il quick fix creiamo questi metodi (vedi codice). Testiamo il tutto–> OK! Analogamente per addPerson e removePerson.

 

Lesson 10 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=kRKmZn76dxs&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv&index=10

Per creare la nostra classe Library, non possiamo usare questa parola, perché in Java indica un insieme di packages. Usiamo quindi MyLibrary(). COme al solito utilizziamo il Test First Approach, creando prima la classe MyLibraryTest() nella cartella test.

Vogliamo testare la classe MyLibrary(), quindi prima di tutto nel constructor mettiamo il metodo testMyLibrary() (vedi codice).

Rispetto ai casi precedenti utilizziamo anche la validazione assertTrue() che valida una condizione boolean (true o false). La condizione da alidare usa l’operatore instanceof . A instanceof B ritorna true se A è di tipo B. Usiamo quindi il Quick Fix per creare la classe MyLibrary(). Ricordiamoci di metterla nella cartella src e non test. Poi continuando con il Quick Fix creiamo il constructor MyLibrary(String string); poi creiamo i fields, poi vediamo che bisogna importare ArrayList. Attenzione che i due oggetti devono essere di tipo ArrayList (correggere) con <Book> e <Person> (vedi codice). Inoltre dobbiamo scrivere this.name = name; (la variabile che passiamo come nome). Dobbiamo creare anche gli array vuoti di libri e persone: books = new ArrayList<Book>(); people = new ArrayList<Person>(); notare le ().

 

Lesson 09 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=ZQluWuxMT60&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv&index=9

Metteremo insieme tutto ciò che abbiamo fatto fino ad ora creando una Library(), classe con le seguenti specifiche:

  1. lista dei libri
  2. lista delle persone che prendono libri in prestito
  3. Quanti libri e/o persone ci sono?

Il punto 3 deve essere stimato. Fortunatamente Java ha una classe ArrayList, che gestisce una lista di oggetti con metodi built-in e che può avere lunghezza qualsiasi.

Familiarizziamo con la classe ArrayList nello scrapbook. Questa classe è parte del package java.util, quindi lo dobbiamo importare usando il pulsante con il triangolino e le righe. Poi creiamo una istanza ArrayList<String> list = new ArrayList<String>(); . <String> definisce il tipo di oggetti presenti nell’array, serve per controllare che non si facciano errori si inserimento nell’array. Usiamo il metodo add per aggiungere qualche elemento e lanciamo il run con l’inspector (vedi codice). Se apriamo la lista, vediamo che l’indicizzazione inizia da 0. Se proviamo ad aggiungere un numero, dà errore perché non è una stringa.

Possiamo ora creare una lista di libri, mettendo al posto di <String> il tipo <Book>. Usiamo add per aggiungere qualche libro (vedi codice). Poi creiamo una persona e le assegnamo un libro (vedi codice).

Alcuni metodi utili per ArrayList:

list.get(int index) –> ritorna l’elemento di indice index. Nel nostro caso ci fornisce un libro. Su questo possiamo usare a sua volta il getPerson() per avere chi l’ha in prestito, e su questo, a sua volta, il getName() per avere il nome della persona.

list.indexOf(Object o) –> ritorna l’indice dell’oggetto. Se l’oggetto non è presente nella lista, dà errore.

remove() –> può essere usato con l’indice e con l’oggetto. Nota: se rimuoviamo un elemento, i seguenti “shiftano” l’indice.

Lesson 08 – Java for Beginners

Vedere video: https://www.youtube.com/watch?v=po2wj0J21J4&index=8&list=PLv6UtFrA7VEu4PtzJaGHHSeZBi6mdJtwv

Creiamo una RELAZIONE tra Book() e Person(), continuando a usare la metodologia Test First. Per far questo modifichiamo la classe di test BookTest(), aggiungendo il metodo testGetPerson(). In questo creiamo una nuova istanza di Book b2, passando direttamente tra parentesi il titolo “War And Peace” e creiamo una nuova istanza di Person p2, poi attribuiamo il nome “Elvis” tramite il setName (vedi codice). Ora dobbiamo scrivere il codice che attribuisce il libro b2 olla persona p2, che è i metodo che sarà testato, e che ancora non è definito nella classe Book(): b2.setPerson(p2); . Poi scriviamo il metodo che ritorna il nome della persona che ha il libro in prestito: possiamo usare due linee o una sola:

due linee:

Person testPerson = p2.getPerson();
String testName = testPerson.getName();

oppure una linea:

String testName = p2.getPerson().getName();

Ora dobbiamo controllare l’eguaglianza con assertEquals(“Elvis”, testName);

Adesso usiamo il Quick Fix per la classe Book: creiamo il metodo setPerson() (anche la dichiarazione del campo person). Nota: viene creato un campo di tipo Private. Private è un access modifiers. Ce ne sono quattro, qui ne vediamo tre: public: tutte le classi hanno accesso; private: solo questa classe in cui è dichiarato ha accesso; senza access modifier: possono accedere solo le classi dello stesso package. Quindi utilizziamo questo terzo caso e togliamo tutti gli access modifiers dalla dichiarazione dei campi.

Il metodo setPerson(p2) è molto semplice: this.person = p2;

Rifacciamo il test e non dà più errori. In questo caso si dice che la classe Book() dipende dalla classe Person(), perché la classe Person() è nominata dentro la classe Book(). La relazione è di tipo 1:1, perché ad un libro corrisponde uno ed una ed una sola persona. Notiamo che possiamo utilizzare person come ogni altra variabile, e non occorre nessun statement di import perché le due classi sono nello stesso package.

Per eseguire tutti i test insieme creiamo una Test Suit Class, selezionando nel Package Explorer il folder “test”, right click > New > Other > JUnit  Test Suit > si chiama AllTest … next (tutti selezionati) finish.  Lo facciamo girare…OK!