Upload
caterina-spano
View
216
Download
0
Embed Size (px)
Citation preview
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
Stackclass 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" <- s2s3 -> "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: 0y: 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 qualsiasilinguaggio procedurale, di un tipo di dato qualsiasi, ad esempio per ipunti 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 ditale tipo. In Java questo fatto e' messo in evidenza richiedendo che ledichiarazioni 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.reale- this.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); }}