03. Corso completo di Programmazione Java – I Fondamenti – Parte II

Bentornati al nostro corso completo di programmazione in JAVA! Quest’oggi terminiamo la carrellata dei componenti che stanno alla base di questo linguaggio, componenti indispensabili e che ci torneranno utili sia per poter iniziare a scrivere i nostri primi semplici programmi in Java, così come quelli più complessi che saremo in grado di realizzare al termine del corso.

In particolare oggi vedremo:

• Quali operatori abbiamo a disposizione
• Caratteristiche del tipo String
• Come fare input/output
• Cosa sono e come usare gli array

Gli operatori

Java mette a disposizione diversi tipi di operatori:

• Operatori aritmetici

  public class FondamentiOperatori { public static void main(String[] args) { System.out.println(4 + 5); // stampa 9 System.out.println(15 / 2); // stampa 7 // modulo: resto della divisione intera (stampa 1) System.out.println(15 % 2); System.out.println(15.0 / 2); // stampa 7.5   int i = 1;   i += 5; //shortcut per i = i + 5 System.out.println(i); // stampa 6   //Operatore di incremento int n = 12; System.out.println(n++); // postfisso: stampa 12, subito dopo n vale 13 System.out.println(++n); // prefisso: stampa 14 System.out.println(--n); // prefisso: stampa 13 } }

  public class FondamentiOperatori { public static void main(String[] args) { System.out.println(4 + 5); // stampa 9 System.out.println(15 / 2); // stampa 7 // modulo: resto della divisione intera (stampa 1) System.out.println(15 % 2); System.out.println(15.0 / 2); // stampa 7.5 int i = 1; i += 5; //shortcut per i = i + 5 System.out.println(i); // stampa 6 //Operatore di incremento int n = 12; System.out.println(n++); // postfisso: stampa 12, subito dopo n vale 13 System.out.println(++n); // prefisso: stampa 14 System.out.println(--n); // prefisso: stampa 13 } }

• Operatori relazionali (==, !=, &&, ||) e ternario

  System.out.println(3 == 7); //stampa false System.out.println(3 != 7); //stampa true   System.out.println(n == 13 && i != 5); //stampa true (n == 13 e i == 6) System.out.println(n == 12 || i == 6); //stampa true (i == 6)   n = 0; int div = n == 0 ? 0 : i / n; System.out.println(div); //stampa zero

  System.out.println(3 == 7); //stampa false System.out.println(3 != 7); //stampa true System.out.println(n == 13 && i != 5); //stampa true (n == 13 e i == 6) System.out.println(n == 12 || i == 6); //stampa true (i == 6) n = 0; int div = n == 0 ? 0 : i / n; System.out.println(div); //stampa zero

  L’operatore ternario è utile in alcuni casi per la sua compattezza: se l’espressione prima di ? è vera restituisce l’espressione a sinistra di :, altrimenti quella a destra.

Per un approfondimento sugli operatori Bitwise, le regole di precedenze e così via rimandiamo al Java Tutorial sugli Operatori.

Il tipo String

Il tipo String è una sequenza di caratteri unicode. Non è un tipo primitivo, ma una classe predefinita contenuta nelle API Java. Tuttavia possiede qualche caratteristica che la rende un po’ speciale. Illustriamone l’utilizzo con un po’ di codice:

public class FondamentiString {
	public static void main(String[] args) {
		String e = ""; // stringa vuota (non null!)
		String greeting = "Hello";
		String s = greeting.substring(0, 3);
		System.out.println(s); // Stampa "Hel"
		s += "lo World"; //concatenazione
		System.out.println(s); // Stampa "Hello World"
 
		System.out.println(greeting); // Stampa sempre "Hello"
	}
}

La cosa particolare di String è che è immutabile: nessuna metodo modifica la stringa su cui è applicato, ma ritorna una nuova istanza con l’esito atteso dal metodo. Se avessimo voluto fare il substring della stringa greeting avremmo dovuto fare così:

greeting = greeting.substring(0, 3);
System.out.println(greeting); // Stavolta stampa "Hel"

Questo è strano, vero sviluppatori C++ 🙂 ? La classe String contiene più di 50 metodi ed è difficile ricordarli tutti: per fortuna possiamo sempre consultare il Javadoc di String.

L’input e l’output

Per quanto riguarda l’Input e l’Output vi diciamo davvero due parole: abbiamo visto che per scrivere in console si utilizza System.out.println(). Per leggere dalla console dando modo ad un utente di digitare parametri in modo interattivo si utilizza la classe Scanner.

Spieghiamo il tutto con un esempio:

import java.util.Scanner;
 
public class FondamentiInputOutput {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("Come ti chiami? ");
		String name = in.nextLine();
		System.out.print("Quanti anni hai? ");
		int age = in.nextInt();
 
		System.out.println("Ciao " + name + ". Il prossimo anno avrai "
				+ (age + 1) + " anni!");
	}
}

Notiamo che per istanziare una variabile di tipo Scanner abbiamo utilizzato la parola chiave new: vedremo che questo sarà il default in tutti i casi in cui non stiamo usando tipi primitivi.

Gli array

Un array è una struttura dati che memorizza una collezione di valori dello stesso tipo. Ogni elemento singolo viene acceduto tramite un indice intero. Vediamo come dichiarare e usare un array con un esempio di codice:

public class FondamentiArray {
 
	public static void main(String[] args) {
		// dichiaro e istanzio un array di interi da 100 posizioni
		int[] a = new int[100];
 
		// ciclo e valorizzo l'array con gli interi da 0 a 99
		for (int i = 0; i < 100; i++)
			a[i] = i;
	}
}

Abbiamo ciclato l’array con un ciclo for: la sintassi e il suo utilizzo sono identici a quelli del C, possiamo quindi consultare il post Istruzioni Iterative del nostro Corso Completo di C per approfondimenti. Inoltre avremo modo di approfondire i costrutti iterativi di Java in uno dei prossimi post.

Per ciclare un array dall’inizio alla fine abbiamo bisogno di sapere quanti elementi contiene: per fortuna ce lo dice il metodo length: un utilizzo tipico è il seguente:

for (int i = 0; i < a.length; i++)
System.out.println(a[i]);

Inizializzazione degli array

Java fornisce un modo comodo di dichiarare un array e inizializzarlo allo stesso tempo:

int[] alcuniNumeriPrimi = { 2, 3, 5, 7, 11, 13 };

Infine gli array possono essere definiti in modo anonimo:

new int[] { 17, 19, 23, 29, 31, 37 }

Conclusioni

Con questa lezione abbiamo terminato la carrellata sui fondamenti di Java e sulla sintassi a basso livello del linguaggio. Occorre ora sedimentare quanto imparato, a tal fine consiglio a tutti di fare un po’ di prove nel vostro fidato IDE e per qualsiasi cosa non esitate a postare un commento qui a fondo articolo o ancor meglio sul nostro forum!

Alla prossima!

Il corso continua con…

04 – Il Controllo del Flusso.