Esercizi
Esercizio
• Si scriva un insieme di classi per i poligoni
nel piano. Ogni poligono è costituito da una
successione di punti, ognuno descritto
tramite le sue coordinate cartesiane. Per
ogni poligono deve essere possibile
calcolare il perimetro.
class Point {
float x,y;
//Questo e' il costruttore
Point(float x, float y) { this.x = x; this.y = y; }
//Restituisce la distanza tra this e un altro punto
public float distance(Point p) {
return Math.sqrt( (this.x - p.x)*(this.x - p.x) +
(this.y - p.y)*(this.y - p.y) );
}
}
class Polygon {
Point[] vertices;
Polygon(int nvertices) { vertices = new Point[nvertices]; }
void setVertex(int n, float x, float y) {vertici[n-1] = new Point(x,y); }
public float perimeter() {
float p = 0;
for (int i = 0; i < vertices.length - 1; i++)
p += vertices[i].distance(vertices[i + 1]);
p += vertices[vertices.length - 1].distance(vertices[0]);
return p;
}
}
Set
Definire una classe per gestire un Set
(collezione di oggetti non ordinata senza ripetizioni)
di interi
class Set
{
private int numbers[];
private int cur_size;
Costruttori – soluzione brutta
public Set(int dimensione) {
cur_size=0;
numbers = new int[dimensione];
}
public Set() {
cur_size=0;
int dimensione=100; //dimensione di default
numbers = new int[dimensione];
}
Costruttori
public Set(int dimensione) {
cur_size=0;
numbers = new int[dimensione];
}
public Set() {
this(100); //dimensione di default
}
public boolean isMember(int n)
{
int i=0;
while(i < cur_size)
{
if(numbers[i]==n) return true;
i++;
}
return false;
}
public void addMember(int n) {
if(isMember(n)) return;
if(cur_size == numbers.length) return;
numbers[cur_size] = n;
cur_size++;
}
public void deleteMember(int n) {
int i=0;
while(i < cur_size) {
if(numbers[i]==n) {
cur_size--;
while(i < cur_size) {
numbers[i]=numbers[i+1];
i++;
}
return;
}
i++;
}
return;
}
public void showSet() {
int i=0; boolean first=true;
String s=new String(“{“);
while(i < cur_size) {
//per non mettere virgole prima del primo elemento
if(first)
first=false;
else s+=" , ";
s+=numbers[i];
i++;
}
s+="}";
System.out.println(s);
}
//main di test
public static void main(String args[])
{
Set s=new Set(100);
System.out.println("Inserisco 1");
s.addMember(1);
System.out.println("Inserisco 7");
s.addMember(7);
System.out.println("Inserisco 9");
s.addMember(9);
System.out.println("Inserisco 11");
s.addMember(11);
System.out.println("Mostro il contenuto del set");
s.showSet();
System.out.println("Elimino il 7");
s.deleteMember(7);
System.out.println("Mostro il contenuto del set");
s.showSet();
}
}
Stack
Definire una classe per gestire una Stack di interi
Stack
class Stack {
int data[];
int first; int max;
Stack(int dimensione) {
data=new int[dimensione];
first=0;
max=dimensione;
}
Stack() {
this(10); }
int pop() {
if (first > 0) {
first--;
return data[first];
}
return -10000; // Bisogna restituire qualcosa
}
void push(int i) {
if (first < max) {
data[first] = i;
first++;
}
}
//main di test
public static void main(String args[])
{
Stack s=new Stack(5);
System.out.println("Inserisco 1");
s.push(1);
System.out.println("Inserisco 7");
s.push(7);
System.out.println("Estraggo un elemento: "+s.pop());
System.out.println("Estraggo un elemento: "+s.pop());
}
}
Cantanti – per gara canora
public class Singer
{
private String cognome;
private String nome;
private String dataDiNascita;
private String luogoDiNascita;
private String canzone;
Getter e setter
/*** @return Returns the cognome. */
public String getCognome()
{
return cognome;
}
/*** @param cognome The cognome to set. */
public void setCognome(String cognome) {
this.cognome = cognome;
}
…
public Singer(String cognome, String nome,
String dataDiNascita,
String luogoDiNascita, String canzone) {
this.cognome = cognome;
this.nome = nome;
this.dataDiNascita = dataDiNascita;
this.luogoDiNascita = luogoDiNascita;
this.canzone = canzone;
}
/*** default constructor */
public Singer()
{}
public String toString() {
return cognome+" "+nome;
}
public boolean equals(Singer s) {
return cognome.equals(s.getCognome()) &&
nome.equals(s.getNome()) &&
canzone.equals(s.getCanzone()) &&
dataDiNascita.equals(s.getDataDiNascita())&&
luogoDiNascita.equals(s.getLuogoDiNascita());
}
public int compareTo(Singer s) {
int n=cognome.compareTo(s.getCognome());
if(n==0)
n=nome.compareTo(s.getNome());
return n;
}
public boolean minoreDi(Singer s) {
return (compareTo(s) < 0);
}
}
Competition
public class Competition {
private static final int numCantanti = 10;
private String denominazione;
private String luogo;
private String nomePresentatore;
private String dataInizio;
private String dataFine;
private Singer[] classifica;
private int indiceCantanti;
public Competition(String denominazione, String luogo,
String nomePresentatore, String dataInizio,
String dataFine)
{
this.denominazione = denominazione;
this.luogo = luogo;
this.nomePresentatore = nomePresentatore;
this.dataInizio = dataInizio;
this.dataFine = dataFine;
indiceCantanti=0;
classifica=new Singer[numCantanti];
}
public String toString() {
return denominazione+" a "+luogo
+" presentata da "+nomePresentatore
+" dal "+dataInizio+" al "+dataFine;
}
public void print() {
System.out.println(this);
}
/** aggiunge il cantante nella posizione
*/
public void addSinger(Singer s,int posizione) {
int pos=posizione-1;
for(int i=numCantanti-1;i>pos;i--)
{
classifica[i]=classifica[i-1];
}
classifica[pos]=s;
if(indiceCantanti<numCantanti-1)
indiceCantanti++;
}
/** aggiunge il cantante nella prima posizione
libera */
public void addSinger(Singer s)
{
if(indiceCantanti<numCantanti-1)
{
classifica[indiceCantanti]=s;
indiceCantanti++;
}
}
/* * cerca il cantante */
public Singer findSinger(String cognome,String nome) {
for(int i=0;i<indiceCantanti;i++)
{
if(classifica[i].getCognome().equals(cognome)
&& classifica[i].getNome().equals(nome))
{
return classifica[i];
}
}
return null;
}
public void deleteSinger(Singer s) {
for(int i=0;i<indiceCantanti;i++)
{
if(classifica[i].equals(s))
{
for(int j=i;j<indiceCantanti-1;j++)
{
classifica[j]=classifica[j+1];
}
classifica[indiceCantanti]=new Singer();
indiceCantanti--;
}
}
}
public void deleteSinger(String cognome,String nome) {
deleteSinger(findSinger(cognome,nome));
}
public String generaClassifica()
{
String str=toString();
for(int i=0;i<indiceCantanti;i++)
str+="\n"+classifica[i]; //viene chiamato toString()
return str;
}
public void stampaClassifica() {
System.out.println(generaClassifica());
}
public String generaListaOrdinata() {
Singer[] ordinati=new Singer[numCantanti];
for(int i=0;i<indiceCantanti;i++) {
ordinati[i]=classifica[i];
}
Continua…
for(int i=0;i<indiceCantanti-1;i++) {
for(int j=0;j<indiceCantanti-1;j++) {
if(ordinati[j+1].minoreDi(ordinati[j])) {
Singer temp=ordinati[j+1];
ordinati[j+1]=ordinati[j];
ordinati[j]=temp;
}
}
}
String str=toString();
for(int i=0;i<indiceCantanti;i++)
str+="\n"+ordinati[i];
return str;
}
Illustrare l'effetto dei seguenti programmi sullo stack
e sullo heap.
class Example1 {
public static void main(String args[]) {
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = s3;
}
}
Risposta:
1- s1 e s2 puntano allo stesso oggetto stringa nello
heap,
s3 punta ad un oggetto diverso nello heap, al quale
punta anche s4:
s1 -> "abc" <- s2
s3 -> "abc" <- s4
Esercizio
Illustrare l'effetto dei seguenti programmi sullo stack e sullo
heap.
class Example2 {
int x;
public static void main(String args[]) {
float a[] = new float[3];
String b[] = new String[3];
String y;
}
}
2- a punta ad un array contenente tre float nello heap (tutti e
tre inizializzati a zero), b punta ad un array nello heap
contenente tre reference impostati a null, x contiene 0, y
contiene null.
a -> [0.0 0.0 0.0]
b -> [null null null]
x: 0
y: null
Notare che x viene inizializzata dal costruttore (ogni classe ha
un costruttore di default). Se x fosse stata dichiarata come
variabile locale del metodo main, il compilatore avrebbe
lamentato
l'assenza di una inizializzazione per x.
Esercizio
Consideriamo una ipotetica implementazione in C, o in un qualsiasi
linguaggio procedurale, di un tipo di dato qualsiasi, ad esempio per i
punti nello spazio:
/* un nuovo tipo per la struttura dati */
typedef struct { float x,y; } *planepoint;
/* le operazioni che manipolano le variabili di tipo planepoint */
void init(planepoint *this, float x, float y) {this->x =x; this->y = y;}
void translate(planepoint *this, float deltax, float deltay) ...
float distance(planepoint *this, planepoint *another) ...
Ridefinirlo in Java
Tutte e tre le operazioni, per definizione, compiono una azione su una
variabile di tipo planepoint, e quindi hanno *almeno* un parametro di
tale tipo. In Java questo fatto e' messo in evidenza richiedendo che le
dichiarazioni delle funzioni vengano messe *dentro* alla
dichiarazione del tipo:
/* dichiarazione del tipo E delle operazioni che manipolano le sue
variabili */
class PlanePoint {
/* i dati di un oggetto di tipo PlanePoint */
float x,y;
/* le operazioni che lo manipolano */
PlanePoint(float x, float y) { this.x = x; this.y = y; } //questa
sostituisce la init
void translate(float deltax, float deltay) ...
float distance(PlanePoint another) ...
}
Le principali differenze sono:
• il parametro this viene automaticamente passato da
Java alle tre operazioni, e quindi NON va
dichiarato (non c'e' bisogno!)
• l'operazione che inizializza un nuovo oggetto di
tipo PlanePoint ha lo stesso nome del tipo, e viene
AUTOMATICAMENTE invocata da Java non
appena viene creato l'oggetto: in questo modo
l'oggetto è sempre in uno stato consistente.
L'operazione viene detta *costruttore*
Scrivere una classe per definire
numeri complessi
class complesso {
private double reale, immaginaria;
public complesso(double i,double j) {
reale=i;
immaginaria=j;
}
public double reale() {
return reale;
}
public double immaginaria() {
return immaginaria;
}
public double modulo() {
return Math.sqrt(this.reale*this.reale+
this.immaginaria*this.immaginaria);
}
public double fase() {
if(this.reale==0)
return Math.PI/2;//se reale=0 fase=90 gradi
else
return
Math.atan(this.immaginaria/this.reale);
//se non conoscete atan non importa ;
}
public complesso somma(complesso altro) {
return new complesso(this.reale+altro.reale,
this.immaginaria+altro.immaginaria);
}
public complesso differenza(complesso altro) {
return new complesso(this.reale-altro.reale,
this.immaginaria-altro.immaginaria);
}
public complesso prodotto(complesso altro) {
return new complesso(this.reale*altro.realethis.immaginaria*altro.immaginaria,
this.reale*altro.immaginaria+
this.immaginaria*altro.reale);
}
public String toString() {
return ""+reale+"+"+immaginaria+"i";
}
public static void main(String args[]) {
complesso a=new complesso(5,6);
complesso b=new complesso(4,0);
complesso c=a.somma(b);
complesso d=a.differenza(b);
complesso e=a.prodotto(b);
double m=a.modulo();
double f=a.fase();
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(m);
System.out.println(f);
}
}