Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Ese01 java

454 views

Published on

Esercizi su Java

Published in: Education
  • Be the first to comment

  • Be the first to like this

Ese01 java

  1. 1. Esercizi
  2. 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. 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. 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. 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. 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]; }
  7. 7. Costruttori public Set(int dimensione) { cur_size=0; numbers = new int[dimensione]; } public Set() { this(100); //dimensione di default }
  8. 8. public boolean isMember(int n) { int i=0; while(i < cur_size) { if(numbers[i]==n) return true; i++; } return false; }
  9. 9. public void addMember(int n) { if(isMember(n)) return; if(cur_size == numbers.length) return; numbers[cur_size] = n; cur_size++; }
  10. 10. 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; }
  11. 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. 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(); } }
  13. 13. Stack Definire una classe per gestire una Stack di interi
  14. 14. Stack class Stack { int data[]; int first; int max; Stack(int dimensione) { data=new int[dimensione]; first=0; max=dimensione; } Stack() { this(10); }
  15. 15. 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++; } }
  16. 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. 17. Cantanti – per gara canora public class Singer { private String cognome; private String nome; private String dataDiNascita; private String luogoDiNascita; private String canzone;
  18. 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; } …
  19. 19. 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() { }
  20. 20. 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()); }
  21. 21. 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); } }
  22. 22. 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;
  23. 23. 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]; }
  24. 24. public String toString() { return denominazione+" a "+luogo +" presentata da "+nomePresentatore +" dal "+dataInizio+" al "+dataFine; } public void print() { System.out.println(this); }
  25. 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. 26. /** aggiunge il cantante nella prima posizione libera */ public void addSinger(Singer s) { if(indiceCantanti<numCantanti-1) { classifica[indiceCantanti]=s; indiceCantanti++; } }
  27. 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; }
  28. 28. 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--; } } }
  29. 29. 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; }
  30. 30. 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…
  31. 31. 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; }
  32. 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. 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. 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. 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. 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. 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. 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. 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. 40. public double reale() { return reale; } public double immaginaria() { return immaginaria; }
  41. 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. 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); }
  43. 43. 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); } }

×