1 Esercizio 1
   2 -----------
   3 Creare in Java una classe “PuntoCartesiano” che rappresenti i punti su un piano 
   4 cartesiano. Definire per la classe i seguenti metodi (oltre agli eventuali altri 
   5 metodi accessori quali: costruttori, toString, get, set, etc.): 
   6 
   7  - PuntoCartesiano leggi(Scanner) 
   8  
   9 che richiede in input le coordinate e costruisce un punto avente tali 
  10 coordinate; 
  11 
  12  - double distanzaDa(PuntoCartesiano) 
  13  
  14 che dato un punto cartesiano restitusce la distanza tra l'oggetto corrente ed 
  15 il punto dato; 
  16 
  17 Scrivere poi un programma (con un main()) che legga da input un array 
  18 di N punti cartesiani (N letto da input), e determini e stampi il punto 
  19 cartesiano con la maggiore distanza dall'origine degli assi e la coppia di punti 
  20 più distanti tra loro.
  21 
  22 
  23 =========
  24 SOLUZIONE
  25 =========
  26 
  27 
  28 ////////////////////////////////////
  29 // INIZIO FILE PuntoCartesiano.java
  30 ////////////////////////////////////
  31 import java.util.Scanner;
  32 import java.lang.Math;
  33 
  34 public class PuntoCartesiano {
  35 
  36     private double x, y;
  37 
  38     public PuntoCartesiano() {
  39 		x = 0;
  40 		y = 0;
  41     }
  42     
  43    public PuntoCartesiano(double coorX, double coorY) {
  44     	x = coorX;
  45     	y = coorY;
  46     }
  47 
  48     public PuntoCartesiano(PuntoCartesiano p) {
  49 		x = p.x;
  50 		y = p.y;
  51     }
  52     
  53     public String toString() {
  54     	return 	"(" + x + "," + y + ")";
  55     }
  56     
  57     public double getX() {
  58         return x;
  59     }
  60     
  61     public void setX(double coorX) {
  62         x = coorX;
  63     }
  64     
  65     public double getY() {
  66         return y;
  67     }
  68     
  69     public void setY(double coorY) {
  70         y = coorY;
  71     }
  72         
  73     public boolean ugualeA(PuntoCartesiano p) {
  74     	return (x == p.x && y == p.y);
  75     }
  76     
  77     public boolean diversoDa(PuntoCartesiano p) {
  78     	return !ugualeA(p);
  79     }
  80     
  81     public double distanzaDa(PuntoCartesiano p)
  82     {
  83     	double l1, l2;
  84     	l1=x-p.x;
  85     	l2=y-p.y;
  86     	return Math.sqrt(Math.pow(l1,2) + Math.pow(l2,2));
  87     }
  88 
  89     public static PuntoCartesiano leggi(Scanner input) {
  90     	System.out.print("Coordinata X: ");
  91     	double coorX = input.nextDouble();
  92     	System.out.print("Coordinata Y: ");
  93     	double coorY = input.nextDouble();
  94     	System.out.println();
  95     	return new PuntoCartesiano(coorX, coorY);
  96     }
  97     
  98 }
  99 ////////////////////////////////////
 100 // FINE FILE PuntoCartesiano.java
 101 ////////////////////////////////////
 102 
 103 
 104 ////////////////////////////////////
 105 // INIZIO FILE DistanzePunti.java
 106 ////////////////////////////////////
 107 import java.util.Scanner;
 108 
 109 public class DistanzePunti {
 110     
 111     public static void main(String[] args) {
 112     	Scanner input = new Scanner(System.in);
 113     	System.out.println("Numero di elementi dell'array?");
 114     	int N=input.nextInt();
 115     	PuntoCartesiano v[] = new PuntoCartesiano[N];
 116     	double d_max;
 117     	int i_max = 0;
 118 
 119     	//Lettura
 120     	for (int i=0; i<N; i++)
 121     		v[i] = PuntoCartesiano.leggi(input);
 122     	
 123     	//Calcolo del punto + distante dall'origine
 124     	PuntoCartesiano origine = new PuntoCartesiano();
 125     	d_max=v[0].distanzaDa(origine); 	
 126     	for(int i=1; i<N; i++)
 127     		if (v[i].distanzaDa(origine)>d_max) {
 128     			d_max=v[i].distanzaDa(origine);
 129     			i_max=i;
 130     		}
 131 
 132     	System.out.println("Il punto + distante dall'origine e' " + v[i_max]);
 133     	
 134 
 135     	//Calcolo della coppia di punti piu' distanti tra loro
 136     	int i2_max=0, j2_max=0;
 137     	double d2_max=0;
 138     	
 139     	for(int i=0; i<N; i++)
 140     		for (int j=i+1;j<N; j++)
 141     			if (v[i].distanzaDa(v[j])>d2_max) {
 142     				d2_max=v[i].distanzaDa(v[j]);
 143     				i2_max=i;
 144     				j2_max=j;
 145     			}
 146 
 147     	System.out.println("la coppia di punti piu' distanti e': " + v[i2_max] + v[j2_max]);
 148 
 149     }
 150     
 151 }
 152 ////////////////////////////////////
 153 // FINE FILE DistanzePunti.java
 154 ////////////////////////////////////
 155 
 156 
 157 
 158 
 159 ///////////////////////////////////////////////////////////////////////////////
 160 
 161 
 162 Esercizio 2
 163 -----------
 164 Creare una classe “Cerchio” caratterizzata da un raggio (rappresentato con un double) e 
 165 da un centro (rappresentato con un oggetto di classe PuntoCartesiano).
 166 Definire per la classe i seguenti metodi (oltre agli eventuali altri metodi accessori, quali
 167 costruttori, toString, get, set, etc.):
 168 
 169  - Cerchio leggi(Scanner)
 170 
 171 che richiede in input raggio e centro e restituisce un nuovo cerchio;
 172 
 173  - double circonfernza()
 174  		
 175 che calcola la circonferenza dell'oggetto corrente;
 176 
 177  - double area()
 178  		
 179 che calcola l'area dell'oggetto corrente;
 180 
 181 Scrivere quindi un programma (con un main()) che faccia le seguenti cose: 
 182 
 183  - legga da input un array "cerchi" di N cerchi (N letto da input)
 184  
 185  - crei due nuovi array: "circonferenze"  e "aree", in cui memorizzare 
 186    rispettivamente le circonferenze e le aree dei cerchi in input (per 
 187    ogni i, circonferenze[i] deve contenere la misura della circonferenza di 
 188    cerchi[i] e aree[i] la misura dell'area). 
 189    
 190  - legga altri 2 cerchi da input, e verifichi se questi si intersecano 
 191    oppure no.
 192 
 193 
 194 =========
 195 SOLUZIONE
 196 =========
 197 
 198 ////////////////////////////////////
 199 // INIZIO FILE Cerchio.java
 200 ////////////////////////////////////
 201 import java.util.Scanner;
 202 import java.lang.Math;
 203 
 204 public class Cerchio {
 205 
 206     private PuntoCartesiano c;
 207     private double r;
 208 
 209     public static final double PI_GRECO = 3.14;
 210 
 211     public Cerchio() {
 212 		c = new PuntoCartesiano();
 213 		r = 0;
 214     }
 215     
 216     public Cerchio(PuntoCartesiano centro, double raggio) {
 217 		c = centro;
 218 		setRaggio(raggio);
 219     }
 220     
 221     public String toString() {
 222     	return 	"Centro: " + c + " Raggio:" + r;
 223     }
 224     
 225     public double getRaggio() {
 226         return r;
 227     }
 228     
 229     public void setRaggio(double raggio) {
 230     	if(raggio > 0)
 231     		r = raggio;
 232     	else
 233     		raggio = 0;
 234     }
 235     
 236     public PuntoCartesiano getCentro() {
 237         return c;
 238     }
 239     
 240     public void setCentro(PuntoCartesiano centro) {
 241         c = centro;
 242     }
 243     
 244     public double circonferenza() {
 245     	return 2*PI_GRECO*r;
 246     }
 247         
 248     public double area() {
 249     	return Math.PI*r*r;
 250     }
 251         
 252     public static Cerchio leggi(Scanner input) {
 253     	System.out.println("Centro");
 254     	PuntoCartesiano centro = PuntoCartesiano.leggi(input);
 255     	System.out.print("Raggio: ");
 256     	double raggio = input.nextDouble();
 257      	System.out.println();
 258      	return new Cerchio(centro,raggio);
 259     }
 260     
 261 }
 262 //////////////////////////////////////
 263 // FINE FILE Cerchio.java
 264 //////////////////////////////////////
 265 
 266 
 267 //////////////////////////////////////
 268 // INIZIO FILE OperazioniSuCerchi.java
 269 //////////////////////////////////////
 270 import java.util.Scanner;
 271 
 272 public class OperazioniSuCerchi {
 273     
 274     public static void main(String[] args) {
 275     	Scanner input = new Scanner(System.in);
 276     	System.out.println("Numero di elementi dell'array?");
 277     	int N=input.nextInt();
 278     	Cerchio cerchi[] = new Cerchio[N];
 279 
 280     	//Lettura
 281     	for (int i=0; i<N; i++)
 282     		cerchi[i] = Cerchio.leggi(input);
 283     	
 284     	//Calcolo circonferenze
 285     	double circonferenze[] = new double[N];   	
 286     	for(int i=0; i<N; i++)
 287     		circonferenze[i] = cerchi[i].circonferenza();
 288 
 289     	//Calcolo aree
 290     	double aree[] = new double[N];   	
 291     	for(int i=0; i<N; i++)
 292     		aree[i] = cerchi[i].area();
 293 
 294     	//Stampa
 295     	System.out.println("I cerchi con le rispettive circonferenze ed aree:");
 296     	for(int i=0; i<N; i++) {
 297     		System.out.println("Cerchio " + (i+1) + ":");
 298     		System.out.println(cerchi[i]);
 299     		System.out.println("Circonferenza: " + circonferenze[i] + " Area: " +aree[i]);
 300     	}
 301     	
 302     	// Lettura di due cerchi e verifica della loro eventuale intersezione
 303     	System.out.println();
 304     	System.out.println("Inserire ora due cerchi: verrà verificato se essi si intersecano oppure no.");
 305     	Cerchio c1 = Cerchio.leggi(input);
 306     	Cerchio c2 = Cerchio.leggi(input);
 307     	
 308     	if (c1.getCentro().distanzaDa(c2.getCentro()) < c1.getRaggio() + c2.getRaggio())
 309     		System.out.println("I due cerchi si intersecano: " +
 310     						   "infatti la distanza tra i due centri è minore della somma dei due raggi");
 311     	else
 312     		System.out.println(" I due cerchi NON si intersecano.");
 313     }
 314     
 315 }
 316 //////////////////////////////////////
 317 // FINE FILE OperazioniSuCerchi.java
 318 //////////////////////////////////////