Fondamenti di Informatica T2 Modulo 2 - unibo.it

Università di Bologna – A.A. 2008/2009

Fondamenti di Informatica T2

Modulo 2

Università degli Studi di Bologna

Facoltà di Ingegneria

Corso di Laurea in Ingegneria Informatica

Anno accademico 2008/2009

Veicoli

• Si desidera realizzare una o più classi che permettano di

modellare diverse tipologie di veicolo.

• Come per il caso della categoria concettuale animale, un

veicolo rappresenta una categoria concettuale astratta

• Non possono esistere istanze di veicolo, perché NON

ESISTE UN VEICOLO QUALSIASI

• Le istanze apparterranno invece alle sue sottoclassi

concrete

Veicoli

• L’entità astratta veicolo è caratterizzata da:

– la marca, che rappresenta la casa costruttrice del

veicolo

– il modello, che rappresenta la versione di veicolo

realizzata dalla casa costruttrice

• ed è descritta tramite:

– la tipologia del veicolo

– lo scopo per cui il veicolo viene impiegato (es. trasporto

persone, trasporto merci, etc.)

– il luogo in cui si muove il veicolo (es. terra ferma, aria,

– il mezzo tramite cui si muove il veicolo (es. ruote,

superfici alari, etc.)

Veicoli

• L’entità astratta veicolo verrà quindi modellata tramite la classe astratta Veicolo, caratterizzata da:

– metodi accessor per accedere alla marca e al modello

del veicolo

– un insieme di metodi per accedere alle stringe

descrittive del veicolo; quindi per accedere a:

• la tipologia del veicolo (tipologia)

• lo scopo per cui il veicolo viene impiegato (scopo)

• il luogo in cui si muove il veicolo (doveSiMuove)

• il mezzo tramite cui si muove il veicolo (siMuoveTramite)

– La rappresentazione a stringa di veicolo (toString)

Veicoli

• La rappresentazione interna di un veicolo in termini di

marca e modello, è indipendente dallo specifico veicolo

• Una prima rappresentazione a stringa del veicolo (tramite la toString) può essere definita indipendentemente dallo

specifico veicolo, in termini della sua rappresentazione

interna e delle stringhe descrittive

Veicoli

• Le stringhe descrittive associate all’entità veicolo dipendono

dallo specifico veicolo modellato

→ è impossibile definire in Veicolo i metodi associati alle

stringhe descrittive

→ i metodi associati alle stringhe descrittive devono essere

astratti

toString utilizza i

metodi astratti!

Veicoli

• Una possibile classificazione per i veicoli:

Si muove in aria

Si muove sulla terra ferma

• Non è ancora possibile definire i restanti metodi astratti

→VeicoloAereo e VeicoloTerrestre sono entrambe

classi astratte

Veicoli

• Aereo e Aliante rappresentano due possibili sottoclassi

concrete di VeicoloAereo:

Veicoli

• Aereo modella l’entità veicolo aereo

– la cui tipologia è Aereo

– che si muove in aria (eredita da VeicoloAereo)

– tramite superfici alari e organo propulsore

– è adibito al trasporto di persone o merci

è possibile definire i

restanti metodi astratti!

Veicoli

Un aliante è caratterizzato anche dal numero di posti

disponibili e dalla dimensione dell’apertura

alare (espressa in metri)

vengono aggiungte nuove

informazioni rispetto algenerico veicolo

la toString di Veicolo

viene ridefinita

• Aliante modella l’entità aliante

– la cui tipologia è Aliante

– tramite superfici alari, senza alcun organo propulsore

– è adibito solo al trasporto di persone

Veicoli

• AereoDiLinea rappresenta una possibile specializzazione

di Aereo:

Veicoli

Un aereo di linea è caratterizzato anche dal

numero di posti disponibili

aggiunge nuove

informazioni rispetto algenerico veicolo …

• AereoDiLinea modella l’entità aereo di linea

– la cui tipologia è Aereo di Linea

– tramite superfici alari e organo propulsore (eredita da Aereo)

– è adibito solo al trasporto di persone (ridefinisce scopo

definito in Aereo)

Veicoli

• Autovettura e Autocarro rappresentano due possibili

sottoclassi concrete di VeicoloTerrestre:

Veicoli

• Autovettura modella l’entità autovettura

– la cui tipologia è Autovettura

– che si muove sulla superficie terrestre (eredita da VeicoloTerrestre)

– tramite ruote

– è adibita solo al trasporto di persone

Un’autovettura è caratterizzata anche dal

numero di posti disponibili

aggiunge nuove

Veicoli

Un autocarro è caratterizzato da una capacità massima

di carico (espressa in quintali) e dal tipo di ruote

aggiunge nuove

• Autocarro modella l’entità autocarro

– la cui tipologia è Autocarro

– che si muove sulla terra ferma (eredita da VeicoloTerrestre)

– tramite ruote

– è adibito solo al trasporto di merce

Veicoli

• Automobile e Autobus rappresentano due possibili

specializzazioni di Autovettura:

Veicoli

Un’automobile è caratterizzata anche dalnumero di porte e dal

numero di volumi

aggiunge nuove

informazioni rispetto allagenerica autovettura …

• Automobile modella l’entità automobile

– la cui tipologia è Automobile

– tramite ruote (eredita da Autovettura)

– è adibita solo al trasporto di un numero limitato di persone (ridefinisce scopo definito in Autovettura)

Veicoli

• Autobus modella l’entità autobus

– la cui tipologia è Autobus

– tramite ruote (eredita da Autovettura) ed

– adibito solo al trasporto di una collettività di persone (ridefinisce scopo definito in Autovettura)

Veicoli

• Furgone rappresenta una possibile specializzazione di

Autocarro:

Veicoli

Un furgone è caratterizzata anche dal

fatto di essere finestrato o meno

aggiunge nuove

informazioni rispetto algenerico autocarro …

• Furgone modella l’entità furgone

– la cui tipologia è Furgone

– tramite ruote (eredita da Autocarro) ed

– adibito solo al trasporto di merce (eredita da Autocarro)

• Si desidera avere la seguente organizzazione dei

package:

Veicoli

veicoli

Veicolo.java

Cartella

di lavoro

Test.java

Furgone.java

import veicoli.*;

public class Test

public static void main(String args[])

Veicolo v[] = {

new Autovettura("Mercedes-Benz", "Berlina", 4),

new Automobile("Fiat", "Panda", 5, 5, 2),

new Autobus("Mercedes-Benz", "O530 Citaro", 28),

new Furgone("Volkswagen", "Caddy", 510,

"singole", false),

new AereoDiLinea("Boeing", "707-300", 250),

new Aliante("Briegleb", "BG 12", 1, 15.24) };

È possibile fare ciò perché sono anche oggetti di tipo Veicolo!

Testing

for(int i = 0; i < v.length; i++)

System.out.println(v[i]);

Testing

• Tramite il polimorfismo verranno richiamati i metodi definiti

dall’oggetto effettivamente referenziato. Ad esempio:

– quando viene stampato l’oggetto v[3], verrà richiamata la

toString definita per gli oggetti della classe Furgone

– la toString di v[0] richiamerà il metodo tipologia

(definito come metodo astratto nella classe Veicolo)

definito per gli oggetti della classe Autovettura

Soluzione - Veicoli

package veicoli;

public abstract class Veicolo

protected String marca;

protected String modello;

public Veicolo(String marca, String modello)

this.marca = marca;

this.modello = modello;

Soluzione - Veicoli…

public String getMarca()

return marca;

public String getModello()

return modello;

public String toString()

return tipologia() + " " + marca + "/" + modello

+ ": veicolo " + scopo() + ", si muove "

+ doveSiMuove() + " tramite “

+ siMuoveTramite() + ".";

… 25

Metodi accessor.Metodi accessor

Soluzione - Veicoli

public abstract String tipologia();

public abstract String scopo();

public abstract String doveSiMuove();

public abstract String siMuoveTramite();

Metodi astratti

Soluzione - Veicoli

package veicoli;

public abstract class VeicoloAereo extends Veicolo

public VeicoloAereo(String marca, String modello)

super(marca, modello);

public String doveSiMuove()

return “in aria”;

Soluzione - Veicoli

package veicoli;

public abstract class VeicoloTerrestre extends Veicolo

public VeicoloTerrestre(String marca, String modello)

public String doveSiMuove()

return “sulla terra ferma”;

Soluzione - Veicolipackage veicoli;

public class Aliante extends VeicoloAereo

private int numeroPosti;

private double aperturaAlare;

public Aereo(String marca, String modello, int

numeroPosti, double aperturaAlare)

this.numeroPosti = numeroPosti;

this.aperturaAlare = aperturaAlare;

public int getNumeroPosti()

return numeroPosti;

public double getAperturaAlare()

return aperturaAlare;

public String tipologia()

return “Aliante”;

public String scopo()

return “adibito al trasporto di persone”;

public String siMuoveTramite()

return “superfici alari senza organo motopropulsore”;

return super.toString() + " Il veicolo ha un'apertura

alare di " + getAperturaAlare() + " metri e può

ospitare un massimo di " + getNumeroPosti()

+ (getNumeroPosti() == 1 ? " persona" : "

persone") + ".";

Soluzione - Veicoli

package veicoli;

public class Aereo extends VeicoloAereo

public Aereo(String marca, String modello)

return “Aereo”;

Soluzione - Veicoli

return “adibito al trasporto di persone o merci”;

return “superfici alari e organo motopropulsore”;

public class AereoDiLinea extends Aereo

private int numeroPosti;

public AereoDiLinea(String marca, String modello, int

numeroPosti)

return numeroPosti;

return “Aereo di linea”;

return super.toString() + " Il veicolo può ospitare un

massimo di " + getNumeroPosti() +

(getNumeroPosti() == 1 ? " persona" : " persone")

+ ".";

public class Autovettura extends VeicoloTerrestre

protected int numeroPosti;

public Autovettura(String marca, String modello, int

numeroPosti)

return numeroPosti;

return “Autovettura”;

return “ruote”;

Soluzione - Veicoli

return super.toString() + " Il veicolo può ospitare un

massimo di " + getNumeroPosti() +

(getNumeroPosti() == 1 ? " passeggero" : "

passeggeri")

+ ".";

Soluzione - Veicoli

package veicoli;

public class Autocarro extends VeicoloTerrestre

protected double capacitàMassima;

protected String tipoRuote;

public Autocarro (String marca, String modello, double

capacitàMassima, String tipoRuote)

this.capacitàMassima = capacitàMassima;

this.tipoRuote = tipoRuote;

public String getTipoRuote()

return tipoRuote;

public double getCapacitàMassima()

return capacitàMassima;

return “Autocarro”;

return “adibito al trasporto di merci”;

return “ruote”;

return super.toString() + " Il veicolo è dotato di

ruote " + getTipoRuote () + " ha una capacità

massima di " + getCapacitàMassima() +

((getCapacitàMassima() == 1) ? " quintale." :

" quintali.");

Soluzione - Veicoli

package veicoli;

public class Automobile extends Autovettura

private int numeroPorte;

private int numeroVolumi;

public Automobile(String marca, String modello, int

numeroPosti, int numeroPorte, int numeroVolumi)

super(marca, modello, numeroPosti);

this.numeroPorte = numeroPorte;

this.numeroVolumi = numeroVolumi;

public int getNumeroPorte()

return numeroPorte;

public int getNumeroVolumi()

return numeroVolumi;

return “Automobile”;

return “adibito al trasporto di un numero limitato di

persone”;

String stringaPadre = super.toString();

return stringaPadre.substring(0, stringaPadre.length()

- 1) + ", possiede " + getNumeroPorte() + "

porte, ed è a " + getNumeroVolumi()

+ ((getNumeroVolumi() == 1) ? " volume." :

" volumi.");

public class Autobus extends Autovettura

public Autobus(String marca, String modello, int

numeroPosti)

super(marca, modello, numeroPosti);

return “Autobus”;

return “adibito al trasporto collettivo di persone”;

public class Furgone extends Autocarro

private boolean finestrato;

public Furgone(String marca, String modello, double

capacitàMassima, String tipoRuote, boolean finestrato)

super(marca, modello, capacitàMassima, tipoRuote);

this.finestrato = finestrato;

public boolean isFinestrato()

return finestrato;

return “Furgone”;

String stringaPadre = super.toString();

return stringaPadre.substring(0, stringaPadre.length()

- 1) + (isFinestrato() ? " ed è" : " e non è")

+ " finestrato.";

import veicoli.*;

public class Test

public static void main(String args[])

Veicolo v[] = {

new Autovettura("Mercedes-Benz", "Berlina", 4),

new Automobile("Fiat", "Panda", 5, 5, 2),

new Autobus("Mercedes-Benz", "O530 Citaro", 28),

new Furgone("Volkswagen", "Caddy", 510,

"singole", false),

new AereoDiLinea("Boeing", "707-300", 250),

new Aliante("Briegleb", "BG 12", 1, 15.24) };

Soluzione - Veicoli

for(int i = 0; i < v.length; i++)

System.out.println(v[i]);

Testing

Extended Phone Plan

Utilizzando i sorgenti messi a disposizione per Operator e Band, realizzare l’infrastruttura per i

piani tariffari vista in aula, in particolare:

Parte 1

1. Implementare la classe PhonePlan astratta

contenente i servizi base per tutti i PhonePlan

2. Implementare la classe PrecisePlan che realizza

l’algoritmo “preciso” di calcolo dei costi di una chiamata

3. Realizzare i test JUnit necessari alla verifica del corretto funzionamento di PrecisePlan

Testing• Evitare di perdere tempo per testare Operator e Band che

sono dati

• Creare Operator e Band di test nel minimo numero

indispensabile

– Un solo Operator

– Due Band:

• Entrambe su tutti i giorni della settimana

• La prima attiva su una parte della giornata, la seconda sulla restante

• Verificare il funzionamento dell’algoritmo di calcolo del

costo della chiamata nel caso in cui la chiamata sia:

– su una sola fascia oraria (un metodo di test)

– a cavallo di due fasce orarie (un altro metodo di test)

Extended Phone Plan

Parte 1 – Diagramma UML

class plans

Precis ePlan

+ getCallCost(Date, Date, String, String) : double

+ PrecisePlan(String, int, int, Operator[])

PhonePlan

- interval: int

- name: String

- operators: Operator ([])

- startCallCost: double

+ getCallCost(Phon eCall) : double

+ getInterval() : int

+ getName() : String

# getOperatorByName(String) : Operator

+ getStartCallCo st() : double

+ isValid() : boolean

# PhonePlan(String, int, int, Operator[])

tlc::Operator

- bands: Band ([])

- name: String

+ getBands() : Band[]

+ getCostPerInterva l(Date) : double

+ Operator(String, Band[])

- selectBandInDay(DayOfWeekEnum) : Band[]

- validateDay(DayOfWeekEnum) : boolean

tlc::Band

- combinedDays: DayOfWeekEnum ([])

- costPerInterval: double

- endTime: SimpleTime

- startTime: SimpleTime

+ Band(SimpleTime, SimpleTime, DayOfWeekEnum[], double)

+ getCombinedDays() : DayOfWeekEnum[]

+ getCostPerInterval() : double

+ getEndTime() : SimpleTime

+ getStartTime() : SimpleTime

+ isInBand(Date) : boolean

+ sortByStartTime(Band[]) : void

-operators

-bands 1. .*

Extended Phone Plan

Parte 2

1. Implementare la classe astratta Option

2. Implementare PrecisePhonePlanWithOption

(sottoclasse di PhonePlan)

3. Realizzare i test JUnit necessari alla verifica del

corretto funzionamento di PrecisePhonePlanWithOption:

• Implementare la classe DummyOption che consenta di

verificare il funzionamento:

1. del sistema di override dei parametri del piano – verificare che

il risultato in termini di costi di una chiamata sia quello atteso

2. del sistema di notifica – verificare che il numero di notifiche

effettuate sia quello atteso

Extended Phone Plan

Parte 2 – Diagramma UML

class plans

PhonePlan

- interval: int

- name: String

- operators: Operator ([])

- startCallCost: double

+ getCallCost(Phon eCall) : double

# getOperatorByName(String) : Operator

+ getStartCallCo st() : double

# PhonePlan(String, int, int, Operator[])

PrecisePlanWithOptions

- options: Option ([])

- findApplicableOption(Date, Operator, String) : Option

+ getOptions() : Option[]

+ getStartCallCost(Date, Op erator, String) : double

+ PrecisePlanWithOptions(String, int, int, Operator[], Option[])

Option

+ getCostPerInterval() : double

+ getStartCallCost() : double

+ isApplicable(Date, Operator, String) : boolean

+ notifyIntervalAccounted() : void

+ overridesCostPerInterval() : boolean

+ overridesInterval() : boolean

+ overridesStartCallCost() : boolean

-options

EPP - Notifiche

• Domanda

– Come si fa a conoscere il numero di notifiche effettuate all’opzione

(ovvero il numero di volte che l’opzione è stata utilizzata per

contabilizzare)?

• Risposta:

– Nel metodo che consente le notifiche inserire un contatore che deve essere visibile da fuori (getX)

– Si costruisce un nuovo piano (PrecisePhonePlanWithOptions)

passando l’opzione DummyOption di cui occorre mantenere un

riferimento

– Al termine del test verificare che il valore del contatore contenuto nella DummyOption abbia il valore atteso in base alle chiamate di

cui è stato calcolato il costo

DummyOption - Dettagli• È un’opzione di test e non è detto che debba avere pienamente

senso…

• Risponde sempre true a isApplicable

• Risponde true ai vari overrideX – avere cura di restituire valori

sensati (e semplici) nei corrispondenti metodi getX

• All’invocazione del metodo di notifica (notifyIntervalAccounted –

invocato dal piano che usa l’opzione) viene incrementato un

contatore

• Al termine del test verificare se il contatore ha raggiunto il valore

atteso ovvero se l’opzione è stata usata il numero di volte previsto

EPP – Note • Notare che il testing di PrecisePhonePlanWithOptions

è indipendente dal testing delle opzioni concrete

“commerciali”

• È stato inserito in un ambiente artificiale di cui la nuova DummyOption fa parte

• Ed è stato sollecitato per verificare le attese

• Si può fare di meglio?

– Eliminare le altre dipendenze concrete (Operator) – come?

– In fase di test, utilizzare un’implementazione alternativa di Operator (più semplice) che NON coinvolga l’entità Band

Note generali sul testing

• L’oggetto/componente argomento di test dovrebbe essere

quanto più isolato possibile…

• …ed immerso in un ambiente il più artificiale possibile…

• …in modo da evitare che il funzionamento (o il NON

funzionamento) del componente stesso sia influenzato dal

funzionamento (o NON funzionamento) degli oggetti che

fanno parte del suo ambiente

Note generali sul testing

• In termini di design, è necessario che una classe

abbia quante meno dipendenze concrete possibile

– per massimizzare la riusabilità – l’unità riusabile è

composta dall’oggetto più tutte le sue dipendenze

concrete)

– per facilitare il testing – l’oggetto è completamente

isolabile e può essere immerso in un ambiente

completamente artificiale: gli oggetti concreti al contorno

sono appositamente studiati solo per i test

Opzioni• Implementare l’opzione YouMeAndTheOther

– Due numeri di telefono a tariffa flat (da definire)

– Intervallo di tariffazione a 60 secondi

– Nessuno scatto alla risposta

• Implementare l’opzione FlatTime

– Mette a disposizione un certo numero di minuti “prepagati” (definibili

all’atto della costruzione)

– Intervallo di tariffazione a 30 secondi

– Nessuno scatto alla risposta

• Verificare il corretto funzionamento delle opzioni

implementate (un test JUnit per ogni classe) prima di

utilizzarle all’interno di un piano

Soluzione - PhonePlanpublic abstract class PhonePlan

private String name;

private int interval;

private double startCallCost;

private Operator[] operators;

protected PhonePlan(String name, int interval, int

startCallCost, Operator[] operators)

this.name = name;

this.interval = interval; //in millisecondi

this.startCallCost = startCallCost;

this.operators = operators;

PhonePlan modella un piano

telefonico astratto che

definisce solo ciò che è

indipendente da una specifica

implementazione.

Soluzione - PhonePlan…

public String getName()

return name;

public int getInterval()

return interval;

public double getStartCallCost()

return startCallCost;

public abstract double getCallCost(Date callStart, Date

callEnd, String destOperator, String destNumber);

getCallCost rappresenta

l’implementazione del calcolo del

costo di una chiamata

getCallCost deve essere

definito come metodo astratto.

public double getCallCost(PhoneCall call)

return getCallCost(call.getCallStart(),

call.getCallEnd(), call.getDestOperator(),

call.getDestNumber());

public boolean isValid()

for (Operator operator : operators)

if (!operator.isValid())

return false;

return true;

… 63

protected Operator getOperatorByName(String operatorName)

Operator selected = null;

for (Operator o : operators)

if (o.getName().equals(operatorName))

selected = o;

break;

return selected;

Soluzione - PrecisePlanpublic class PrecisePlan extends PhonePlan

public PrecisePlan(String name, int interval, int

startCallCost, Operator[] operators)

super(name, interval, startCallCost, operators);

@Override

public double getCallCost(Date callStart, Date callEnd,

String destOperator, String destNumber)

Operator selected = getOperatorByName(destOperator);

if (selected == null)

return -1;

PrecisePlan definisce l’algoritmo “preciso” per il calcolo

del costo di una chiamata.

Soluzione – PrecisePlan…

GregorianCalendar cal = new GregorianCalendar();

cal.setTime(callStart);

Date currentDateTime = cal.getTime();

double durationCost = 0;

while (currentDateTime.compareTo(callEnd) < 0)

durationCost +=

selected.getCostPerInterval(currentDateTime);

cal.setTime(currentDateTime);

cal.add(GregorianCalendar.MILLISECOND, getInterval());

currentDateTime = cal.getTime();

return getStartCallCost() + durationCost;

Soluzione - PrecisePlanTestpublic class PrecisePlanTest

public static PrecisePlan createPlan()

return new PrecisePlan("TIM", 1000, 10, new Operator[]

{OperatorTest.createOperator()});

public void testGetCallCost()

PhonePlan plan = createPlan();

Soluzione - PrecisePlanTest

cal.set(GregorianCalendar.DAY_OF_WEEK,

GregorianCalendar.WEDNESDAY);

cal.set(GregorianCalendar.HOUR_OF_DAY, 22);

cal.set(GregorianCalendar.MINUTE, 24);

cal.set(GregorianCalendar.SECOND, 0);

cal.set(GregorianCalendar.MILLISECOND, 0);

Date callStart = cal.getTime();

Crea l’inizio chiamata …

Date callEnd = cal.getTime();

double actual =

plan.getCallCost(callStart, callEnd, "TIM", "");

assertEquals(1810, actual);

… crea la fine chiamataappartenente alla stessa

fascia oraria e …

… verifica che il costo della chiamata sia quello

che ci aspettiamo.

Soluzione - PrecisePlanTest…

public void testGetCallCost_CrossBand()

double actual = plan.getCallCost(callStart, callEnd,

"TIM", "");

… crea la fine chiamataappartenente ad una

fascia oraria diversa e …

che ci aspettiamo.

Soluzione - PrecisePlanTest…

public void testGetCallCost_CrossBand_Dat()

cal.set(GregorianCalendar.MINUTE,58);

GregorianCalendar.THURSDAY);

"TIM", "");

… crea la fine chiamataappartenente ad una

fascia oraria diversa e …

che ci aspettiamo.

Soluzione - Option

public abstract class Option

public abstract boolean isApplicable(Date istantTime,

Operator operator, String destNumber);

public abstract boolean overridesCostPerInterval();

public abstract double getCostPerInterval();

public abstract boolean overridesInterval();

public abstract int getInterval();

public abstract boolean overridesStartCallCost();

public abstract double getStartCallCost();

public abstract void notifyIntervalAccounted();

Option modella un’entità che: 1) permette di ridefinire uno o

più parametri del piano tariffario; 2) può avere uno stato che cambia in base al suo utilizzo.

Soluzione - PrecisePlanWithOptionspublic class PrecisePlanWithOptions extends PhonePlan

private Option[] options;

public PrecisePlanWithOptions(String name, int interval,

int startCallCost, Operator[] operators,

Option[] options)

super(name, interval, startCallCost, operators);

this.options = options;

public Option[] getOptions()

return options;

Contiene un insieme di opzioni di cui non conosce i dettegli implementativi!

PrecisePlanWithOption

modella un piano con opzioni.

@Override

public double getCallCost(Date callStart, Date callEnd,

String destOperator, String destNumber)

Operator selected = getOperatorByName(destOperator);

if (selected == null)

return -1;

cal.setTime(callStart);

Date currentDateTime = cal.getTime();

double startCallCost =

getStartCallCost(currentDateTime, selected,

destNumber);

Soluzione - PrecisePlanWithOptions

double durationCost = 0;

while (currentDateTime.compareTo(callEnd) < 0)

Option option =

findApplicableOption(currentDateTime, selected,

destNumber);

int intervalToAdd = getInterval();

if (option != null)

if (option.overridesInterval())

intervalToAdd = option.getInterval();

durationCost += option.getCostPerInterval();

option.notifyIntervalAccounted();

… 77

Sfrutta le opzioni nel calcolo del costo di una chiamata.

Sfrutta la prima opzione applicabile nel calcolo del costo di una chiamata.

durationCost +=

selected.getCostPerInterval(currentDateTime);

cal.setTime(currentDateTime);

cal.add(GregorianCalendar.MILLISECOND,

intervalToAdd);

currentDateTime = cal.getTime();

return startCallCost() + durationCost;

public double getStartCallCost(Date currentTime,

Operator operator, String

destNumber)

Option option =

findApplicableOption(currentTime, operator,

destNumber);

return (option != null &&

option.overridesStartCallCost()) ?

option.getStartCallCost() : getStartCallCost();

private Option findApplicableOption(Date istantTime,

Operator operator, String destNumber)

for (Option option : options)

if (option.isApplicable(istantTime, operator,

destNumber))

return option;

return null;

Recupera la prima opzione applicabile.

Soluzione - DummyOptionpublic class DummyOption extends Option

private int notificationCount;

public DummyOption()

notificationCount = 0;

public int getNotificationCount()

return notificationCount;

@Override

public double getCostPerInterval()

return 2;

DummyOption è una classe

realizzata per verificare il corretto funzionamento di

PrecisePhonePlaneWithOption

Soluzione - DummyOption…

@Override

return 30000;

@Override

return 0;

@Override

public boolean isApplicable(Date istantTime,

return true;

Soluzione - DummyOption

@Override

public void notifyIntervalAccounted()

notificationCount++;

@Override

public boolean overridesCostPerInterval()

return true;

Soluzione - DummyOption

@Override

public boolean overridesInterval()

return true;

@Override

public boolean overridesStartCallCost()

return true;

Soluzione - PrecisePlanWOptionsTestpublic class PrecisePlanWOptionsTest

public static PrecisePlanWithOptions createPlan()

return new PrecisePlanWithOptions("TIM", 1000, 10,

new Operator[] {OperatorTest.createOperator()},

new Option[] {new DummyOption()});

public static PrecisePlanWithOptions createPlan(Option[]

options)

return new PrecisePlanWithOptions("TIM", 1000, 10,

new Operator[] {OperatorTest.createOperator()},

options);

public void testGetCallCostDateDateStringString()

DummyOption1 option = new DummyOption1();

PrecisePlanWithOptions plan = createPlan(new Option[]

{ option });

Soluzione - PrecisePlanWOptionsTest

"TIM", "");

assertEquals(6, option.getNotificationCount());

Verifica il sistema di override dei parametri del piano e il sistema di

notifica.

public void testGetStartCallCostDateOperatorString()

assertEquals(0.0, createPlan().getStartCallCost(new

Date(), OperatorTest.createOperator(), “MyNumber”));

public class YouMeAndTheOther extends Option

private String destNumber1;

private String destNumber2;

private double costPerInterval;

public YouMeAndTheOther(String destNumber1,

String destNumber2, double costPerInterval)

this.destNumber1 = destNumber1;

this.destNumber2 = destNumber2;

this.costPerInterval = costPerInterval;

return true;

Soluzione - YouMeAndTheOther

Permette l’override del costo relativo all’intervallo di

tariffazione.

@Override

return costPerInterval;

@Override

Operator operator, String

destNumber)

return destNumber.equals(destNumber1) ||

destNumber.equals(destNumber2);

L’opzione è applicabile solo se il destinatario della chiamata è

destNumber1 o destNumber2.

@Override

return true;

@Override

return 30000;

@Override

return true;

… 91

Permette l’override dell’intervallo di tariffazione.

Permette l’override del costo relativo allo scatto alla risposta.

@Override

return 0;

@Override

return "You, Me And The Other - " + destNumber1 + " and

+ destNumber2;

public class FlatTime extends Option

private int flatPeriod;

public FlatTime(int flatPeriod)

this.flatPeriod = flatPeriod;

return true;

@Override

return 0;

… 93

Soluzione - FlatTime

Permette l’override del costo relativo all’intervallo di

tariffazione.

@Override

return flatPeriod >= getInterval();

@Override

return true;

@Override

return 30000;

… 94

Permette l’override dell’intervallo di tariffazione.

E’ applicabile solo se il numero di minuti

prepagati corrente è maggiore dell’intervallo

di tariffazione.

@Override

return true;

@Override

return 0;

Permette l’override del costo relativo allo scatto alla risposta.

@Override

flatPeriod -= getInterval();

@Override

return "It's a Flat Time! - Minutes left: " +

((float)flatPeriod / 60000);

Fondamenti di Informatica T2 Modulo 2 - unibo.it

Documents

Transcript of Fondamenti di Informatica T2 Modulo 2 - unibo.it

T2 T Presentazione 2011

Mazzacane, - unibo.it

Rosa Pugliese - unibo.it · Rosa Pugliese - unibo.it

Pianta Piano Terra -Rialzatomedia.immobiliare.it/allegati/54552900/descrizione_progetto.pdf · T3-t3 T3-t3 T2-t2 T2-t2 3, 24m 9, 2 30m 2 7, 75m 2 17. 60 m 2 6, 20 rm 2 18. 10m 2 6.

Esercizi - unibo.it

Fondamenti di Informatica L-A - unibo.it

Fondamenti di Informatica T-1 - unibo.it...Fondamenti del linguaggio Java Alcuni algoritmi e strutture dati in Java Ereditarietà Strutture dati avanzate in Java 12 Laboratorio Guidato

alberto.montanari@unibo.it ...

Indice - unibo.it

Fondamenti di Informatica T-1 - unibo.it · 21 Bonus di valutazione È possibile acquisire un bonus di 4 punti: 2 punti per la partecipazione alle esercitazioni in laboratorio (massimo

Amplificatori - unibo.it

Fondamenti di Informatica T2 Modulo 2 - lia.deis.unibo.itlia.deis.unibo.it/Courses/FondT2-0809-INF/lab/slides-x2/03.Lab3a... · Fondamenti di Informatica T2 Modulo 2 ... (N.B. Se

Fondamenti di Informatica A - unibo.it · 2020. 2. 18. · Fondamenti di Informatica e Laboratorio T-AB Prof. Luca Foschini Prof. Rebecca Montanari Tutor Domenico Scotece Anno accademico

Termodinamica - unibo.it

può - unibo.it

Elettronica e Telecomunicazioni · Per calcolare T2 useremo invece la rampa crescente ed imporremo che dopo un tempo T2, l’usita raggiunga VTH. Come si nota T1 = T2 = T/2. Nel caso

Fondamenti di Informatica T-1 - unibo.it · 22 Ricevimento Il ricevimento studenti è previsto per tutta la durata dell’A.A. Avviene per appuntamento Richiesta via email da indirizzo

Come si esegue l’esame: quali macchine, quali tecniche. · TSE T2 assiale SE T1 sagittale GE T2* coronale STIR sagittale GE T2* assiale di rotula Protocollo Resnick Alto Campo FS

curr - unibo.it · Web viewcurr - unibo.it

T2 Reverb - LuckyMusic