Newsgroup: it.comp.java
Titolo: problema programmino java

allora ho creato questo programmino:
 > //questo programma serve a calcolare il perimetro di un trinagolo e a 
definire che tipo di triangolo sia dando come dati di imput solo //le 
coordinate cartesiane dei tre vertici
 > public class pertriang {
 >
 >     public static void main(String[] args) {
 >         // TODO Auto-generated method stub
 >
 >         double a, b, c;
 >         int ax, ay, bx, by, cx, cy;
 >         ax = 1;
 >         ay = 2;
 >         bx = 3;
 >         by = 4;
 >         cx = 5;
 >         cy = 6;
 >         a=Distanza.misuratore(ax, ay, bx, by);
 >         b=Distanza.misuratore(ax, ay, cx, cy);
 >         c=Distanza.misuratore(cx, cy, bx, by);
 >         System.out.println("a= " + a);
 >         System.out.println("b= " + b);
 >         System.out.println("c= " + c);
 >         System.out.println("il perimetro e': " + (a+b+c));
 >         verifica.verifica1(a, b, c);
 >         //trovaequilatero.tequilatero(a, b, c);
 >
 >     }
 >
 >     static class Distanza {   //classe per calcolare i lati del triangolo
 >
 >         public static double misuratore(int ax, int ay, int bx, int by) {
 >             double a; // misura lati triangolo
 >             a = Math.sqrt((Math.pow((ax - bx), 2)) + (Math.pow((ay - 
by), 2)));
 >             return a;
 >         }
 >     }
 >     static class verifica{   //classe per la verifica del tipo di 
triangolo
 >         public static void verifica1(double a,double b,double c){
 >             //boolean d;
 >             if (a==b && a==c && c==b)
 >                 System.out.println("il triangolo e' equilatero");
 >                 //else if (a==b && b!=c && c!=a)
 >                     //System.out.println("il triangolo e'isoscele");
 >                 else if(a==b | a==c | b==c)
 >                     System.out.println("il triangolo e'isoscele");
 >                 else if (a+b<c | a+c<b |b+c<a)
 >                     System.out.println("il tringolo non esiste");
 >                 else                     System.out.println("il 
triangolo e' scaleno");
 >
 >         }
 >     }
 >     /**
 >      * @author Lux
 >      *
 >      */
 >     static class trovaequilatero{
 >         public static void tequilatero(int a,int b,int c){
 >             a=b=c=0;
 >
 >         }
 >
 >     }
 > }
ora il problema mio risiede nella classe trovaequilatero dove vorrei che 
il programma verificasse in maniera automatica se nel range di 
coordinate xy da 0 a 10 esistano dei triangoli equilateri e me li mostri 
sullo schermo.
Come posso fare?


Punto primo: se vuoi usare un linguaggio ad oggetti smetti di
BRUTALIZZARLO creando programmi
che usano classi (statiche!) solo come gusci per metodi statici.
Chirisciti prima le idee (con l'aiuto di un buon testo Java)
su cosa sono gli oggetti e come e perche' si usano. Quanto alla tua
domanda non sono sicuro di averla capita, ma credo basti un bel ciclo
for che cicla su tutte le possibili coordinate che ti interessano,
calcola la lunghezza dei lati  (con la la formula di siatzna tra due
punti in geometria analitica ) e va a vedere se i lati sono uguali...

 
sul fatto di brutalizzare il linguaggio java ti do' ragione infatti ho 
pronta gia la seconda versione che e' formata dalla classe principale 
che a sua volta richiama una seconda classe contenente tutti i metodi 
necessari,per la storia delle coordinate mi sono bloccato sulla 
creazione dell'algoritmo per la risoluzione del mio problema...
Non capisco come posso usare il for per le 6 coordinate....
Mi ci applico stasera e vedo cosa ne esce fuori.
Grazie per i suggerimenti
Lucio

 che usano classi (statiche!) solo come gusci per metodi statici.
purtroppo e' colpa di molti corsi tenuti da professori alle superiori
e addirittura all'universita'. Mi ricordo quando seguii il corso di
informatica 2, trattava il C++. Non si fece accenno quasi per niente
alla progammazione ad oggetti e non si uso' quasi per niente il
paradigma ad oggetti. Che schifo! :)
Lo stesso l'ho visto fare addirittura con il JAVA, linguaggio che di
per se' dovrebbe "forzarti" ad usare il paradigma ad oggetti.
m.


OK, infatti prima di buttarti sull algoritmo ti consiglio di
riformulare la tua soluzione all'analisi dei trangoli in maniera ad
oggetti,
tipo cosi':
package geometry;
public class Triangle
{
   private Vertex[] vertexes = new Vertex[3];
   public static final double EPSILON= Math.pow (10.0, -9.0);
   public Triangle(double ax, double ay, double bx, double by, double
cx, double cy )
   {
	   vertexes[0]= new Vertex(ax, ay);
	   vertexes[1]= new Vertex(bx, by);
	   vertexes[2]= new Vertex(cx, cy);
   }
   public double sideAB()
   {
	   return Math.sqrt(diffABx()*diffABx() + diffABy()*diffABy());
   }
   public double sideBC()
   {
	   return Math.sqrt(diffBCx()*diffBCx() + diffBCy()*diffBCy());
   }
   public double sideCA()
   {
	   return Math.sqrt(diffCAx()*diffCAx() + diffCAy()*diffCAy());
   }
   public boolean isEquilateral()
   {
	   return (Math.abs(sideAB()-sideBC()) < EPSILON && Math.abs(sideBC()
- sideCA()) < EPSILON);
   }
   private double diffABx()
   {
	   return vertexes[0].getX() - vertexes[1].getX();
   }
   private double diffABy()
   {
	   return vertexes[0].getY() - vertexes[1].getY();
   }
   private double diffBCx()
   {
	   return vertexes[1].getX() - vertexes[2].getX();
   }
   private double diffBCy()
   {
	   return vertexes[1].getY() - vertexes[2].getY();
   }
   private double diffCAx()
   {
	   return vertexes[2].getX() - vertexes[0].getX();
   }
   private double diffCAy()
   {
	   return vertexes[2].getY() - vertexes[0].getY();
   }
}
class Vertex
{
	private double x;
	private double y;
	public Vertex(double x, double y)
	{
		this.x = x;
		this.y = y;
	}
	public double getX()
	{
		return x;
	}
	public double getY()
	{
		return y;
	}
}
class Test
{
	public static void main(String[] args)
	{
		Triangle equi= new Triangle(0, 2.0* Math.sqrt(3.0),-2.0, 0.0, 2.0,
0.0 );
		System.out.println(equi.isEquilateral());
		System.out.println(equi.sideAB());
		System.out.println(equi.sideBC());
		System.out.println(equi.sideCA());
	}
}
Quanto al trovare tutti  i triangoli uquilateri nel range 1-10.. mmmm
immagino che tu intenda con coordinate a valore intero, senno' sono
infiniti...comunque l' approccio brutale e' fare un orgia di for
annidati (tipo sei) in cui si cicla su tutti i possibili valori delle
coordinate x e y dei tre vertici. Una slzuine meno brutale andrebbe a
eliminare in casi in cui i tre vertici stanno sulla stessa linea e
tutte le permutaizon in cui il traingolo e' lo stesso ma si scambiano
solo le posizioni die vertici a b  c. Questo pero' te lo fai da solo
senno' che ci stai  a fare all' universita'? ( a parte rimorchiare
ovviamente ;)


Beh strano perche' non c'e' nulal di piu' smeplice e piu' intuitivo
della programmazione ad oggetti...ma in effetti molti dei ragazzi che
arrivano ai miei corsi di formazione professionale mi dicono.. esame
Java li', tesi in Java la' e poi hanno un livello agghiacciante. Non
ho ancora capito se sia colpa di prof vecchi e ammuffiti o di studenti
fancazzisti e con scarsa passione ma sospetto un "concorso di colpa" ;)