public class Esempio03 {
	// Variabili di tipo non intero
	static int x;
	static String y;
	static boolean b;
	static double w1,w2,w3;
		
	public static void main(String[] args) {
		// Assegnamento
		x=5; 
		y="Ciao";
		
		x = 3*x - 4;
		System.out.println("x vale " + x);

		// La somma tra String è la concatenazione
		y = y + " mondo! "; 
		System.out.println(y);			 // Ciao mondo!
		
		// String e interi si possono sommare, convertendo implicitamente l'intero in String
		System.out.println(y + x);       // Ciao mondo! 11
		
		// Nota: non vale l'associativa!
		System.out.println((y + x) + x); // Ciao mondo! 1111
		System.out.println(y + (x + x)); // Ciao mondo! 22
		
		// Un booleano vale o true o false
		b = true;
		System.out.println(b);	 // true
		x=5;
		// Confronto maggiore
		b = (x > 4);			 // true
		// Confronto maggiore o uguale
		b = (x >= 5);			 // true
		// Confronto uguaglianza: operatore ==
		b = (x == 6);			 // false
		// Confronto diversità: opeatore !=
		b = (x != 6);            // true
		// Operatore AND: &&
		b = (x > 4) && (x < 10); // true AND true == true
		// Operatore OR: ||
		b = (x > 4) || (x < -10); // true OR false == true
		// Operatore NOT: !
		b = !(x == 5);	          // false
		
		// In un if è possibile usare qualunque espressione di tipo boolean.
		if (x>0 && !b && !(x==6)) {
			System.out.println("Ecco!"); // Viene stampato
		}
		
		// Le variabili di tipo "double" contengono "numeri con la virgola".
		w1 = 3.14 ;
		// Notate che vengono memorizzate solo un certo numero di cifre, non tutte.
		// Di conseguenza le variabili double non rappresentano i numeri reali in
		// modo esatto, ma contengono un errore di rappresentazione intrinseco.
		
		// A volte questo può portare a conseguenze paradossali.
		// Per esempio la somma non è associativa (!!), come si vede qui sotto.
		w1 = 1000.0 * 1000.0 * 1000.0 * 1000.0 * 1000.0 * 1000.0; // numero enorme
		w2 = -w1;
		w3 = 1.0; // numero piccolo
		System.out.println("w1 = " + w1); // 1.0E18 cioè 1.0 * (10 alla 18esima)
		// Questo if sotto dovrebbe controllare se 1 == 1, e sembrerebbe vero...
		// ... ma non lo è!
		if ( (w1 + w2) + w3 == w1 + (w2 + w3) ) {
			System.out.println("Vale la associativa!");
		} else {
			System.out.println("NON vale la associativa?!?");
			System.out.println("(w1+w2)+w3 = " + ((w1+w2)+w3)); // 1.0
			System.out.println("w1+(w2+w3) = " + (w1+(w2+w3))); // 0.0
		}
		// Il problema è che w1 ha molte cifre (18 decimali) e quindi aggiungere w2=1
		// andrebbe a modificare la 18esima cifra, che in realtà non viene memorizzata.
		// Quindi w1+1 è uguale a w1 (!) e questo fa violare l'associatività.
		// In generale, le equazioni che valgono sui reali NON valgono sui double
		// a causa del troncamento delle cifre. In genere, salvo casi patologici
		// di "instabilità numerica", valgono a meno di un errore "piccolo",
		// dove "piccolo" va rapportato alle grandezze su cui facciamo i conti.
		// Quindi 1.0 è "piccolo" rispetto a w1=10^18.
	}

}