Appunti Ingegneria del software

Java attributi

Final, Static e Interface

Final: Fa diventare l'attributo immutabile. Per i metodi, blocca l'ereditarietà (non possono essere ereditati).

Static: Fa diventare l'attributo condiviso tra le varie istanze della classe.

Interface: Sono metodi astratti, non posso istanziarla.

Binding classi e gerarchie

Classi statiche e dinamiche

Padre x = new Figlio(); OK!
Figlio x = new Padre(); NO!

Overriding e overloading

Overriding: Sovrascrive una funzione.

Overloading: Cambio tipi parametri (parametro = classe Figlio).

Binding dinamico

Nel binding dinamico vengono considerati i tipi dinamici di chiamante e parametri.

Estendibilità e principio di Liskov

L'estendibilità tramite ereditarietà

È garantita solo se possiamo sostituire oggetti della sottoclasse a quelli della classe padre.

Principio di sostituzione di Liskov

Gli oggetti della sottoclasse devono rispettare il contratto della sovraclasse, ma il contratto può essere esteso per coprire ulteriori casi.

Regole

• Regola della segnatura: Un sottotipo deve avere tutti i metodi del sovratipo e segnature compatibili.
• Regola dei metodi: Le chiamate ai metodi del sottotipo devono comportarsi in modo compatibile a quelle del sovratipo.
• Regola delle proprietà: Il sottotipo deve preservare tutti i public invarianti.

Testing

Coverage

• Statements: Tutte le istruzioni.
• Edge Coverage: Tutti i rami.
• Path Coverage: Tutti i rami con ogni combinazione logica e tutte le possibili combinazioni di percorsi.

Sono tagliate le condizioni: (False || Ex), (True && Faux) → Ex ritorna ignorato.
Anche le condizioni d'uscita dei cicli sono decisioni.

Collezioni in Java

Dichiarazione e metodi

List <Tipo> Nome = new ArrayList<Tipo>();

Metodi di ArrayList

• indexOf(value): Ritorna il primo indice dove il valore dato è trovato nella lista (-1 se non trovato).
• toString(): Ritorna una rappresentazione in stringa della lista, ad esempio "[3, 42, -7, 15]".

Programmazione funzionale

Sintassi e metodi

Obj. _method(Type Par₁, Type Par₂) → { funzione }

Posso trasformare la collection in uno stream con collection.stream()

Funzioni native

• forEach(x → f_cn) → Esegue f_cn per ogni valore dello stream
• filter(x → cond_i) → Filtra lasciando nello stream solo gli elementi che rendono vera x
• map(x → x.*.2_etc) → Trasforma i dati dello stream
• distinct() → Elimina i duplicati
• sorted() → Ordina
• reduce(x → acc+o, f_cmb(a,b)) → Unisce gli stream risultanti
• collect(collection.total(x)) → Trasforma lo stream in una collection

Operazioni meno comuni

Optional

Permette di operare su dati ignorando il fatto che alcuni dati possano essere assenti (NULL).

Creazione

public class Persona {
    private String nome;
    private Optional<String> indirizzo;
    
    public Persona(String nome, String indirizzo) {
        this.nome = nome;
        this.indirizzo = Optional.ofNullable(indirizzo);
    }

    public Persona(String nome) {
        this.nome = nome;
        this.indirizzo = Optional.empty();
    }

    public String getNome() {
        return nome;
    }

    public Optional<String> getIndirizzo() {
        return indirizzo;
    }
}

• Optional.of(val) = crea un optional con quel valore
• Optional.empty() = crea un optional vuoto

Utilizzo

Optional<Persona> o = ...
String commenti = o
    .flatMap(p -> p.getIndirizzo())
    .flatMap(i -> i.getCommenti())
    .orElse("no comment");

1. o.get() (sconsigliato)
2. o.ifPresent(fun) = esegue una funzione su <T> se dati presenti, la esegue
3. o.flatMap(m -> Optional<T>) = esegue una funzione da <T> -> Optional<T>
4. o.orElse(val) = restituisce T/val se esiste

Programmazione concorrente

Creazione e gestione di thread

Come far partire un Thread

Timer timer = new Timer(…);
Thread t = new Thread(timer);
t.start();
public class Timer implements Runnable {
    @Override
    public void run() {
    }
}

Main class

Nel main devo dichiarare un oggetto thread e inizializzarlo dandogli come parametro la classe apposita.
La classe deve implementare la classe runnable e fare l'override del metodo run.

Programmazione funzionale

Runnable r = () -> doSomething();
t = new Thread(r);
t.start();

— Oppure —

Thread t = new Thread( () -> doSomething() );
t.start();

Viene creata una nuova classe che implementa runnable e implementa il metodo run con il metodo "doSomething".

Wait e notify

public void addAccount(String clientName) {
    synchronized(accName) {
        accName.add(clientName);
        if(accName.contains(clientName))
            accName.add(clientName);
            accBalance.add(0.0);
    }
    accName.notifyAll();
}

public double getBalance(String clientName) {
    synchronized(accName) {
        while(!accName.contains(clientName))
            try { accName.wait(); }
            catch(InterruptedException ex) { ex.printStackTrace(); }
        int pos = accName.indexOf(clientName);
        return accBalance.get(pos);
    }
}

• Uso synchronized per eliminare gli accessi concorrenti.
• Posso mettere in pausa un Thread con wait() (con try-catch), in questo modo viene rilasciato il lock.
• I metodi in wait sono svegliati da notifyAll().
• Posso dichiarare attributi utili: solo come lock = new Object().

In maniera asincrona

Quando l'esercizio chiede di fare qualcosa in "maniera asincrona" rispetto agli altri metodi: dobbiamo creare un nuovo Thread che sia comunque ben "sincronizzato e non causi conflitti" con gli altri Thread.

public void setAllAsync(long val) {
    new Thread() {
        public void run() {
            synchronized(data) {
                code;
                data.notifyAll();
            }
        }
    }.start();
}

JML

Invariante e astrazione

Formalizzazione di una proprietà: astrazione di una classe.

Osservatore

Sono metodi puri che restituiscono informazioni sullo stato. Posso avere JML solo su metodi attributi pubblici e puri.

Indicatori

• Requires: Pre-condizione
• Ensures: Post-condizione
• Signals (Ex_c): Eccezioni B_c condizione Eccezionale
• Also: Specifica sotto metodo
• forall: (forall type x; range; condizione)
• Exist: (Exist type x; condizione;)
• Result: \Result indica il valore di ritorno del metodo
• Old: \Old (old) mem lo stato dell'istanza prima del metodo
• Contains: reso x ∈ Struttura
• num_of: (Num_of int i; P(i, a[i]) n° di i che rendono vera Pi0 ≤ a[i]0

I metodi

"Puri" non modificano lo stato.
Ricade di esplicitare che lo stato non cambia quando serve.

Tips

• Devo mettere le condizioni negli ENSURES che escludono i SIGNAL
• I SIGNAL non escludono i REQUIRES

UML

Tipi di diagrammi

• Struttura: Diagrammi di classi e oggetti
• Comportamento: Diagrammi dei casi d'uso
• Interazione: Diagrammi di sequenza

Diagramma di classi

Classi

Attributi → [visibilità] [nome] : [tipo]
Metodi → [visibilità] [nome (lista parametri)] : [tipo restituito]
[visibilità]: + = public, - = private, # = protected, ~ = friendly

Associazioni

Indicano una relazione tra le classi. Nell'implementazione delle classi viene aggiunto un numero di istanze della classe in relazione con quella da implementare.

Aggregazioni

Forma particolare di associazione. Una parte è in relazione con l'oggetto. Tutte le parti esistono "singolarmente".

Composizioni

Aggregazione forte. Le parti componenti non esistono senza il contenitore. In JAVA Aggregazione ≠ Composizione.

Ereditarietà

Padre <|-- Figlio. Viene implementata con "class Figlio extends Padre".

Interfaccia

Non posso istanziare un'interfaccia.

Dipendenze

La classe persona ha bisogno della classe libro per funzionare. Lo indico in questo modo.

Diagramma d'interazione

Descrivono il comportamento dinamico di un gruppo di "oggetti" che interagiscono per risolvere il problema.

Tipi di messaggi

• Sincrono -->
• Asincrono ->
• Risposta - - >(metodi) Termine L.imoTerminizazione oggetto

Pattern

Tipi di pattern

• Creazionali: riguardano il processo di creazione di oggetti.
• Strutturali: riguardano composizione di classi e oggetti.
• Comportamentali: riguardano interazioni tra oggetti e si distribuiscono responsabilità.

Factory Method

Serve per disaccoppiare il codice che fa uso di un tipo da quello che ne implementa il costruttore.

1. L'interfaccia che viene chiamata per costruire il prodotto esatto.
2. La classe factory, che decide quale costruttore usare.
3. I costruttori reali.

Singleton

Viene usato quando si vuole una sola istanza (quindi non si vuole rendere pubblico il costruttore). Un metodo statico dà accesso alla sola istanza.

Adapter

Serve per far interagire 2 diversi sistemi. Viene creata una classe che converte le chiamate ai metodi dell'altra classe.

Proxy

Postpone e estrai la istanziazione di oggetti “pesanti”. Si interpone il proxy tra chiamante e chiamato con la stessa interfaccia dell'oggetto pesante. Il proxy può fare preprocessing o rendere le chiamate più facili.

Observer

Più oggetti si mettono in “ascolto” e vengono informati nel caso il Subject cambia stato.