Esercizio 1
-----------
Creare in Java una classe “PuntoCartesiano” che rappresenti i punti su un piano 
cartesiano. Definire per la classe i seguenti metodi (oltre agli eventuali altri 
metodi accessori quali: costruttori, toString, get, set, etc.): 

 - PuntoCartesiano leggi(Scanner) 
 
che richiede in input le coordinate e costruisce un punto avente tali 
coordinate; 

 - double distanzaDa(PuntoCartesiano) 
 
che dato un punto cartesiano restitusce la distanza tra l'oggetto corrente ed 
il punto dato; 

Scrivere poi un programma (con un main()) che legga da input un array 
di N punti cartesiani (N letto da input), e determini e stampi il punto 
cartesiano con la maggiore distanza dall'origine degli assi e la coppia di punti 
più distanti tra loro.


=========
SOLUZIONE
=========


////////////////////////////////////
// INIZIO FILE PuntoCartesiano.java
////////////////////////////////////
import java.util.Scanner;
import java.lang.Math;

public class PuntoCartesiano {

    private double x, y;

    public PuntoCartesiano() {
		x = 0;
		y = 0;
    }
    
   public PuntoCartesiano(double coorX, double coorY) {
    	x = coorX;
    	y = coorY;
    }

    public PuntoCartesiano(PuntoCartesiano p) {
		x = p.x;
		y = p.y;
    }
    
    public String toString() {
    	return 	"(" + x + "," + y + ")";
    }
    
    public double getX() {
        return x;
    }
    
    public void setX(double coorX) {
        x = coorX;
    }
    
    public double getY() {
        return y;
    }
    
    public void setY(double coorY) {
        y = coorY;
    }
        
    public boolean ugualeA(PuntoCartesiano p) {
    	return (x == p.x && y == p.y);
    }
    
    public boolean diversoDa(PuntoCartesiano p) {
    	return !ugualeA(p);
    }
    
    public double distanzaDa(PuntoCartesiano p)
    {
    	double l1, l2;
    	l1=x-p.x;
    	l2=y-p.y;
    	return Math.sqrt(Math.pow(l1,2) + Math.pow(l2,2));
    }

    public static PuntoCartesiano leggi(Scanner input) {
    	System.out.print("Coordinata X: ");
    	double coorX = input.nextDouble();
    	System.out.print("Coordinata Y: ");
    	double coorY = input.nextDouble();
    	System.out.println();
    	return new PuntoCartesiano(coorX, coorY);
    }
    
}
////////////////////////////////////
// FINE FILE PuntoCartesiano.java
////////////////////////////////////


////////////////////////////////////
// INIZIO FILE DistanzePunti.java
////////////////////////////////////
import java.util.Scanner;

public class DistanzePunti {
    
    public static void main(String[] args) {
    	Scanner input = new Scanner(System.in);
    	System.out.println("Numero di elementi dell'array?");
    	int N=input.nextInt();
    	PuntoCartesiano v[] = new PuntoCartesiano[N];
    	double d_max;
    	int i_max = 0;

    	//Lettura
    	for (int i=0; i<N; i++)
    		v[i] = PuntoCartesiano.leggi(input);
    	
    	//Calcolo del punto + distante dall'origine
    	PuntoCartesiano origine = new PuntoCartesiano();
    	d_max=v[0].distanzaDa(origine); 	
    	for(int i=1; i<N; i++)
    		if (v[i].distanzaDa(origine)>d_max) {
    			d_max=v[i].distanzaDa(origine);
    			i_max=i;
    		}

    	System.out.println("Il punto + distante dall'origine e' " + v[i_max]);
    	

    	//Calcolo della coppia di punti piu' distanti tra loro
    	int i2_max=0, j2_max=0;
    	double d2_max=0;
    	
    	for(int i=0; i<N; i++)
    		for (int j=i+1;j<N; j++)
    			if (v[i].distanzaDa(v[j])>d2_max) {
    				d2_max=v[i].distanzaDa(v[j]);
    				i2_max=i;
    				j2_max=j;
    			}

    	System.out.println("la coppia di punti piu' distanti e': " + v[i2_max] + v[j2_max]);

    }
    
}
////////////////////////////////////
// FINE FILE DistanzePunti.java
////////////////////////////////////




///////////////////////////////////////////////////////////////////////////////


Esercizio 2
-----------
Creare una classe “Cerchio” caratterizzata da un raggio (rappresentato con un double) e 
da un centro (rappresentato con un oggetto di classe PuntoCartesiano).
Definire per la classe i seguenti metodi (oltre agli eventuali altri metodi accessori, quali
costruttori, toString, get, set, etc.):

 - Cerchio leggi(Scanner)

che richiede in input raggio e centro e restituisce un nuovo cerchio;

 - double circonfernza()
 		
che calcola la circonferenza dell'oggetto corrente;

 - double area()
 		
che calcola l'area dell'oggetto corrente;

Scrivere quindi un programma (con un main()) che faccia le seguenti cose: 

 - legga da input un array "cerchi" di N cerchi (N letto da input)
 
 - crei due nuovi array: "circonferenze"  e "aree", in cui memorizzare 
   rispettivamente le circonferenze e le aree dei cerchi in input (per 
   ogni i, circonferenze[i] deve contenere la misura della circonferenza di 
   cerchi[i] e aree[i] la misura dell'area). 
   
 - legga altri 2 cerchi da input, e verifichi se questi si intersecano 
   oppure no.


=========
SOLUZIONE
=========

////////////////////////////////////
// INIZIO FILE Cerchio.java
////////////////////////////////////
import java.util.Scanner;
import java.lang.Math;

public class Cerchio {

    private PuntoCartesiano c;
    private double r;

    public static final double PI_GRECO = 3.14;

    public Cerchio() {
		c = new PuntoCartesiano();
		r = 0;
    }
    
    public Cerchio(PuntoCartesiano centro, double raggio) {
		c = centro;
		setRaggio(raggio);
    }
    
    public String toString() {
    	return 	"Centro: " + c + " Raggio:" + r;
    }
    
    public double getRaggio() {
        return r;
    }
    
    public void setRaggio(double raggio) {
    	if(raggio > 0)
    		r = raggio;
    	else
    		raggio = 0;
    }
    
    public PuntoCartesiano getCentro() {
        return c;
    }
    
    public void setCentro(PuntoCartesiano centro) {
        c = centro;
    }
    
    public double circonferenza() {
    	return 2*PI_GRECO*r;
    }
        
    public double area() {
    	return Math.PI*r*r;
    }
        
    public static Cerchio leggi(Scanner input) {
    	System.out.println("Centro");
    	PuntoCartesiano centro = PuntoCartesiano.leggi(input);
    	System.out.print("Raggio: ");
    	double raggio = input.nextDouble();
     	System.out.println();
     	return new Cerchio(centro,raggio);
    }
    
}
//////////////////////////////////////
// FINE FILE Cerchio.java
//////////////////////////////////////


//////////////////////////////////////
// INIZIO FILE OperazioniSuCerchi.java
//////////////////////////////////////
import java.util.Scanner;

public class OperazioniSuCerchi {
    
    public static void main(String[] args) {
    	Scanner input = new Scanner(System.in);
    	System.out.println("Numero di elementi dell'array?");
    	int N=input.nextInt();
    	Cerchio cerchi[] = new Cerchio[N];

    	//Lettura
    	for (int i=0; i<N; i++)
    		cerchi[i] = Cerchio.leggi(input);
    	
    	//Calcolo circonferenze
    	double circonferenze[] = new double[N];   	
    	for(int i=0; i<N; i++)
    		circonferenze[i] = cerchi[i].circonferenza();

    	//Calcolo aree
    	double aree[] = new double[N];   	
    	for(int i=0; i<N; i++)
    		aree[i] = cerchi[i].area();

    	//Stampa
    	System.out.println("I cerchi con le rispettive circonferenze ed aree:");
    	for(int i=0; i<N; i++) {
    		System.out.println("Cerchio " + (i+1) + ":");
    		System.out.println(cerchi[i]);
    		System.out.println("Circonferenza: " + circonferenze[i] + " Area: " +aree[i]);
    	}
    	
    	// Lettura di due cerchi e verifica della loro eventuale intersezione
    	System.out.println();
    	System.out.println("Inserire ora due cerchi: verrà verificato se essi si intersecano oppure no.");
    	Cerchio c1 = Cerchio.leggi(input);
    	Cerchio c2 = Cerchio.leggi(input);
    	
    	if (c1.getCentro().distanzaDa(c2.getCentro()) < c1.getRaggio() + c2.getRaggio())
    		System.out.println("I due cerchi si intersecano: " +
    						   "infatti la distanza tra i due centri è minore della somma dei due raggi");
    	else
    		System.out.println(" I due cerchi NON si intersecano.");
    }
    
}
//////////////////////////////////////
// FINE FILE OperazioniSuCerchi.java
//////////////////////////////////////