2. 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.
3. 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) );
}
}
4. 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;
}
}
5. 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;
6. 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];
}
11. 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);
}
12. //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();
}
}
16. //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());
}
}
17. Cantanti – per gara canora
public class Singer
{
private String cognome;
private String nome;
private String dataDiNascita;
private String luogoDiNascita;
private String canzone;
18. 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;
}
…
24. public String toString() {
return denominazione+" a "+luogo
+" presentata da "+nomePresentatore
+" dal "+dataInizio+" al "+dataFine;
}
public void print() {
System.out.println(this);
}
25. /** 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++;
}
26. /** aggiunge il cantante nella prima posizione
libera */
public void addSinger(Singer s)
{
if(indiceCantanti<numCantanti-1)
{
classifica[indiceCantanti]=s;
indiceCantanti++;
}
}
27. /* * 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;
}
32. 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;
}
}
33. 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
34. 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;
}
}
35. 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.
36. 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
37. 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) ...
}
38. 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*
39. Scrivere una classe per definire
numeri complessi
class complesso {
private double reale, immaginaria;
public complesso(double i,double j) {
reale=i;
immaginaria=j;
}
40. public double reale() {
return reale;
}
public double immaginaria() {
return immaginaria;
}
41. 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 ;
}
42. 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);
}