Progettazione di un contatore
Specifiche: Realizzazione di una classe come ADT che funga da contatore: scrivere inoltre un breve
programma che ne illustri i metodi ed il funzionamento. Non ci sono vincoli sui metodi da
implementare e sul loro funzionamento.
Indice
Discussione del codice
Listato di Counter.java
Listato di Example.java
Generazione del bytecode
Esecuzione
Documentazione
Strumenti
Autore
Discussione del codice
Counter.java
Il progetto parte dall’idea che un oggetto di questo tipo debba necessariamente implementare alcune
funzioni. Un contatore deve poter essere incrementato, decrementato, resettato e deve poter
restituire il proprio valore.
Mi sono preoccupato quindi di estendere le funzionalità sopra elencate. Per esempio potere settare
un valore qualsiasi nel contatore: questo compito è delegato alla funzione setValue.
Un discorso analogo si può effettuare per l’incremento ed il decremento: per questo ho sottoposto
ad overload i relativi metodi . Inoltre il metodo setStep permette di settare un valore di passo per
l’incremento. Ho previsto anche la possibilità di utilizzare dei limiti di conteggio: le funzioni
coinvolte in questo processo sono setMinOn, setMaxOn, setMin e setMax. Le prime si occupano
dell’attivazione/disattivazione dei limiti che per default sono off. Le ultime invece impostano i
limiti veri e propri. Le funzioni di conteggio sono state quindi adattate per consentire il
riconoscimento di questi limiti.
Siccome spesso è utile poter confrontare il valore del contatore con quello di un altro ho ritenuto
necessario implementare dei metodi relativi all’algebra relazionale: in particolare si occupano di
questo compito le funzioni equalTo, greaterThan e lessThan.
Tutti i metodi implementati sono stati resi accessibili al cliente in quanto pubblici. Le variabili
coinvolte nei vari processi sono private e quindi non accessibili direttamente.
Example.java
La classe Example è un breve programma di testing sul funzionamento del contatore: caratteristica
fondamentale è la presenza del metodo main, nel cui corpo sono incluse le vere e proprie “azioni”
del programma.
Listato dell’oggetto Counter.java:
/**
* Counter.java
* Created on 28 aprile 2001
*
* @author Luca Gardelli
* @version 1.0
*
* A Counter is an objects that counts integer values:
* it provides methods to be incremented, to be decremented, to be reset,
* to retrieve its value, to set its value
*/
public class Counter {
//public stuff
/**
* Constructs a counter with default values.
* High and low threshold aren't active.
*/
public Counter() {
value=0;
step=1;
maxon=false;
minon=false;
}
/**
* Constructs a counter based on k and m parameters.
* High and low threshold aren't active.
* @param k - value amount
* @param m - step amount
*/
public Counter(int k, int m) {
value=k;
step=m;
maxon=false;
minon=false;
}
/**
* Checks boundary constraint (if on) and then
* increments the counter value of k.
* @param k - increment amount
*/
public void inc(int k) {
if(maxon) {
if (value + k <max)
value += k;
}
else value += k;
}
/**
* Checks boundary constraint (if on) and then increments
* the counter value of a step.
*/
public void inc() {
if(maxon) {
if(value+step<max)
value += step;
}
else value += step;
}
/**
* Checks boundary constraint (if on) and then
* decrements the counter value of k.
* @param k - decrement amount
*/
public void dec(int k) {
if(minon) {
if (value-k>min)
value -= k;
}
else value -=k;
}
/**
* Checks boundary constraint (if on) and then
* decrements the counter value of a step.
*/
public void dec() {
if(minon) {
if (value-step>min)
value -= step;
}
else value -= step;
}
/**
* Retrieves the counter value.
*/
public int getValue() {
return value;
}
/**
* Sets the counter value to k.
* @param k - value amount
*/
public void setValue(int k) {
value=k;
}
/**
* Sets the counter value to zero.
*/
public void reset() {
value=0;
}
/**
* Sets the counter step.
* @param k - step amount
*/
public void setStep(int k) {
step=k;
}
/**
* Sets min value assignable to the counter value.
* @param k - low threshold amount
*/
public void setMin(int k) {
min=k;
}
/**
* Sets max value assignable to the counter value.
* @param k - high threshold amount
*/
public void setMax(int k) {
max=k;
}
/**
* Activates/Deactivates low threshold.
*/
public void setMinOn() {
minon = !minon;
}
/**
* Activates/Deactivates high threshold.
*/
public void setMaxOn() {
maxon = !maxon;
}
/**
* Returns true if two counter have the same value.
* @param k - Counter object
*/
public boolean equalTo(Counter k) {
return value == k.value;
}
/**
* Returns true if our counter value is greater than the parameter one.
* @param k - Counter object
*/
public boolean greaterThan(Counter k) {
return value > k.value;
}
/**
* Returns true if our counter value is less than the parameter one.
* @param k - Counter object
*/
public boolean lessThan(Counter k) {
return value < k.value;
}
//private stuff
private int value,step,min,max;
private boolean minon,maxon;
}
Listato dell’oggetto Example.java:
/**
* Example.java
* Created on 28 aprile 2001
*
* @author Luca Gardelli
* @version 1.0
*
* Shows how to use Counter.class
*/
public class Example {
public static void main(String[] argv) {
Counter c1= new Counter();
Counter c2= new Counter(4,2);
c1.inc();
c2.inc();
System.out.println("c1 = " + c1.getValue());
System.out.println("c2 = " + c2.getValue());
System.out.println("c2 = c1 ? " + c1.equalTo(c2));
c2.inc(3);
c1.setStep(5);
c1.inc();
System.out.println("c2 < c1 ? " + c2.lessThan(c1));
c2.reset();
c2.setMinOn();
c2.setMin(0);
System.out.println("c2 = " + c2.getValue() + " Low threshold active- min=0");
c2.dec(20);
System.out.println("c2 = " + c2.getValue());
}
}
Generazione del bytecode
Il java come soluzione alla portabilità dei programmi utilizza una forma intermedia rispetto ai
linguaggi interpretati e quelli compilati (eseguibili). Il compilatore java trasforma il sorgente (.java)
nel bytecode, che non è esattamente un eseguibile ma nemmeno il sorgente stesso. Il file generato
(.class) viene eseguito dal macchina virtuale java.
Per generare il codice nel bytecode ho utilizzato il comando Javac con i seguenti parametri:
Javac Example.java Counter.java
Esecuzione
Per eseguire il bytecode il JDK della Sun mette a disposizione il comando Java. La riga di comando
utilizzata è:
Java Example
L’esecuzione del programma ha prodotto come output le seguenti linee:
c1 = 1
c2 = 6
c2 = c1 ? false
c2 < c1 ? false
c2 = 0 Low threshold Active – min=0
c2 = 0
Documentazione
Il JDK della Sun mette a disposizione un comando per la generazione di documentazione, a partire
dai commenti inseriti nel sorgente. Di particolare rilievo le linee @author, @version, @param che
permettono rispettivamente di mettere in evidenza l’autore del codice, la versione della classe e i
parametri passati ai metodi.
Dalla riga di comando si può quindi generare la documentazione con la linea:
Javadoc Example.java Counter.java –author -version
Nota I comandi Java, Javac e Javadoc sono stati utilizzati nella maniera sopra descritta in quanto
le due classi non fanno parte di un package specifico.
I parametri –author e –version sono necessaria a javadoc per tradurre correttamente rispettivamente
i tags @author e @version
Strumenti
Per la realizzazione di questo progetto mi sono avvalso di Forte for Java CE per la stesura del
codice e di Java 2 SDK per la generazione del bytecode e della documentazione. Tutti i file di
progetto, bytecode e di documentazione sono presenti all’interno della directory data.
Autore
Realizzato da Luca Gardelli studente al II anno del DU di Ingegneria Informatica sede di Cesena.
Indirizzo e-mail: [email protected]
