Relaz 1

Costantini Diego 107724
04/05/2001
Esercitazione del 26/04/2001
Programmi di esempio Java: contatori e utilizzo di package
Le classi utilizzate sono state Example e Counter, il primo come componente software e il secondo
come template.
Sono stati compilati ed eseguiti quattro tipi di esercizi, ognuno con e senza l’uso di package (per
esempio nella cartella “ex1” è stato utilizzato il package ex1, mentre in quella “ex1a” è stato
omesso).
L’unica differenza che comporta l’utilizzo del package riguarda la compilazione e l’esecuzione, che
devono essere lanciate dalla cartella immediatamente superiore a quella del package (“javac
ex1\Counter.java” e “javac ex1\Example.java” per la compilazione, e “java ex1.Example” per
l’esecuzione).
E’ fondamentale ricordarsi di lanciare dalla posizione esatta tali comandi, ed è altrettanto
fondamentale ricordarsi che Java è case sensitive, e quindi necessita di un uso corretto delle
maiuscole/minuscole.
In questi esempi sono presenti anche commenti (parti del programma inclusi tra /* e */) che possono
facilmente documentare il programma eseguendo il comando javadoc.
Esercizio1: ex1
Counter.java
package ex1;
/**
*
* A Counter is an object that counts integer values.
* It provides services to be reset,
* to be incremented and to retrieve its value
*
* @author Pippo Baudo
* @version 1.0
*/
public class Counter {
/**
* Resets the counter value.
*
* The value is reset to zero.
*/
public void reset(){
value=0;
}
/**
* Increments the counter value.
*/
public void inc(){
value++;
}
/**
* Gets the counter value.
*/
public int getValue(){
return value;
}
// private data
private int value;
}
Le funzioni svolte da questa classe oggetto sono:
reset(), che riporta il contatore al valore prestabilito, in questo caso 0;
inc(), che incrementa il valore del contatore, in questo caso di 1;
getValue(), che restituisce il valore attuale del contatore.
Example.java
package ex1;
/**
* Example application explaining
* the use of Counter object
*/
public class Example {
public static void main (String args[]) {
Counter c= new Counter();
c.reset();
c.inc();
c.inc();
System.out.println(c.getValue());
}
}
Questo componente software, invece, definisce, tramite il costruttore Counter(), un riferimento “c”
all’oggetto contatore, dopodiché lo resetta e lo incrementa 2 volte; infine stampa a video il valore
del contatore in quel momento, che nel nostro esempio è 2.
In entrambi i sorgenti, “package ex1” indica il package di appartenenza della classe, e
semplicemente eliminando tale riga in entrambi i file si elimina la dipendenza dal package, come
mostrato nei file in “ex1a”:
Counter.java (ex1a)
/**
*
* A Counter is an object that counts integer values.
* It provides services to be reset,
* to be incremented and to retrieve its value
*
* @author Pippo Baudo
* @version 1.0
*/
public class Counter {
/**
* Resets the counter value.
*
* The value is reset to zero.
*/
public void reset(){
value=0;
}
/**
* Increments the counter value.
*/
public void inc(){
value++;
}
/**
* Gets the counter value.
*/
public int getValue(){
return value;
}
// private data
private int value;
}
Example.java (ex1a)
/**
* Example application explaining
* the use of Counter object
*/
public class Example {
public static void main (String args[]) {
Counter c= new Counter();
c.reset();
c.inc();
c.inc();
System.out.println(c.getValue());
}
}
(d’ora in poi non considererò più la presenza o meno dei package).
Esercizio2: ex2a
Example.java
public class Example {
public static void main (String args[]) {
Counter c= new Counter();
c.reset();
c.inc();
c.inc();
System.out.println(c.getValue());
}
}
class Counter {
public void reset(){
value=0;
}
public void inc(){
value++;
}
public int getValue(){
return value;
}
// private data
private int value;
}
Questa volta l’oggetto contatore è contenuto direttamente nel componente software Example, che,
una volta compilato, produrrà sia la classe Counter che quella Example (Counter.class e
Example.class).
Esercizio3: ex3a
Counter.java
/**
*
* A Counter is an object that counts integer values.
* It provides services to be reset,
* to be incremented and to retrieve its value
*
*/
public class Counter {
/**
* Resets the counter value.
*
* The value is reset to zero.
*/
public void reset(){
value=0;
}
/**
* Increments the counter value.
*/
public void inc(){
value++;
}
/**
* Gets the counter value.
*/
public int getValue(){
return value;
}
/**
* Tests if two counters are equal.
*
* Two counters are equal when they have
* the same value.
*/
public boolean equals(Counter x){
return value==x.value;
}
// private data
private int value;
}
Questa volta l’oggetto contatore è in grado di eseguire una funzione in più, cioè la comparazione tra
due contatori, che restituisce un valore booleano (TRUE se hanno lo stesso valore, altrimenti
FALSE).
Example.java
public class Example {
public static void main (String args[]) {
Counter c1 = new Counter();
c1.reset();
c1.inc();
System.out.println("c1 = "+c1.getValue());
Counter c2 = c1;
c2.inc();
System.out.println("c1 = "+c1.getValue());
System.out.println("c2 = "+c2.getValue());
//
Counter c3 = new Counter();
c3.inc();
System.out.println(c3.equals(c1));
c3.inc();
System.out.println(c3.equals(c1));
}
}
Il componente software, questa volta, creerà un riferimento “c1” al contatore tramite un costruttore,
poi lo azzererà, lo incrementerà e stamperà il suo valore a video (1).In seguito assegnerà un altro
riferimento “c2” (Counter c2=c1) e verrà ancora incrementato, poi si visualizzeranno i valori di
“c1” (2) e “c2” (2).
Infine verrà creato un nuovo riferimento ad un nuovo contatore, che verrà incrementato una sola
volta e comparato con c1 (restituendo FALSE) ed incrementato ancora una volta e comparato di
nuovo (questa volta con risultato TRUE).
Esercizio4: ex4a
Counter.java
/**
*
* A Counter is an object that counts integer values.
* It provides services to be reset,
* to be incremented and to retrieve its value
*
*/
public class Counter {
/**
* Constructs a counter with default value (1).
*/
public Counter(){
value=1;
}
/**
* Constructs a counter providing a start value.
*/
public Counter(int v){
value=v;
}
/**
* Resets the counter value.
*
* The value is reset to zero.
*/
public void reset(){
value=0;
}
/**
* Increments the counter value.
*/
public void inc(){
value++;
}
/**
* Increments the counter value.
*
* @param n amount of the increment
*/
public void inc(int n){
value+=n;
}
/**
* Gets the counter value.
*/
public int getValue(){
return value;
}
/**
* Tests if two counters are equal.
*
* Two counters are equal when they have
* the same value.
*/
public boolean equals(Counter x){
return value==x.value;
}
// private data
private int value;
}
Ora l’oggetto da la possibilità di essere incrementato di un valore n, e il suo valore iniziale di
default, se non specificato diversamente, sarà 1.
Example.java
public class Example {
public static void main (String args[]) {
Counter c1 = new Counter();
c1.inc();
Counter c2 = new Counter(10);
c2.inc();
System.out.println("c1 = "+c1.getValue());
System.out.println("c2 = "+c2.getValue());
}
}
Ora si ha un riferimento ad un contatore con valore iniziale di default (1) che viene incrementato ed
un altro riferimento ad un contatore con valore iniziale 10 anch’esso incrementato (entrambi gli
incrementi sono unitari); infine vengono visualizzati i valori dei contatori, rispettivamente pari a 2 e
11.
Esercizio aggiuntivo: exmio
Counter.java
Mantenuto uguale al precedente.
Example.java
public class Example {
public static void main (String args[]) {
Counter c1 = new Counter();
c1.inc(3);
c1.inc(5);
c1.inc(3);
Counter c2 = new Counter(9);
c2.inc();
c2.inc();
c2.inc();
System.out.println("c1 = "+c1.getValue());
System.out.println("c2 = "+c2.getValue());
}
}
Questa volta si ha un valore finale uguale a 12 per entrambi i contatori grazie a valori iniziali diversi
ma anche ad incrementi diversi.