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() { int dimensione=100; //dimensione di default

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--;  numbers[i]=numbers[i+1]; 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); }

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()); }

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.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);