Sintassi di Java

Java è molto simile a C++, quindi per il programmatore C++ la seguente lezione sarà in buona parte già nota. Fare attenzione però perché esistono piccole ma importanti differenze.

Identificatori

I nomi di variabile sono chiamati identificatori. Un identificatore valido deve cominciare con una maiuscola, minuscola o carattere _, seguito da maiuscole, minuscole, numeri o ancora _. Gli identificatori sono case sensitive. Non sono consentiti identificatori con nomi riservati con parole chiave del linguaggio (es. if, for, ecc.).

E’ una buona prassi usare come prima lettera una minuscola per nomi di variabile e di funzioni, ed usare nomi “parlanti” per le variabili, onde ricordare a cosa servono. L’uso di identificatori molto brevi, come x, y, i, ecc. può essere comunque utile in variabili ad uso circoscritto e con visibilità locale.

Tipi di dato base

I tipi di dato base fondamentali del C++ sono: int, float (virgola mobile), double (virgola mobile doppia parola), long (intero doppia parola), boolean, char. Ne sono presenti anche altri.

Si ricorda che la parola è nel computer la dimensione (in bit o byte) del tipo di dato. Siccome l’architettura è unica (la JVM) la parola è sempre a 32 bit.

In Java ogni variabile va dichiara indicando prima il tipo.

Stringhe

Un tipo speciale e molto importante è String, che identifica una stringa.

String saluto = "Ciao";
System.out.println(saluto);

La stringa può contenenere testo di lunghezza qualsiasi e si comporta come un tipo base, quindi è assegnabile direttamente da un literal o da un’altra variabile.

E’ possibile concatenare stringhe:

salutaMario = saluto + " Mario";
System.out.println(saluto);

Nella prossima lezione vedremo perchè è speciale.

Array

Gli array sono contenitori di elementi dello stesso tipo e di lunghezza fissa. Si definiscono in vari modi:

• Dichiarazione e creazione array vuoto:

int[] array = new int[10];

• Dichiarazione e creazione array con valori:

int[] array = {1,2,3,4,5];

• Dichiarazione e assegnazione separati:

tipo[] nomeArray;
nomeArray = new tipo[lunghezza];

Per l’accesso si accede mediante l’operatore parentesi quadre:

nomeArray[3] = 100;
System.out.print(nomeArray[2]);

E’ possibile conoscere la dimensione dell’array con la proprietà length:

System.out.print(nomeArray.length);

E’ anche possibile ordinare gli array:

Arrays.sort(array);

Le matrici si definiscono in questo modo:

float matrix[][];
float otherMatrix[][] = new otherMatrix[3][2];
float nextMatrix[][] = {{1,2},{3,4},{5,6}};

L’accesso è con un doppio indice:

matrix[3][4] = 150;
System.out.print(matrix[2][3]);

Stampa e lettura da console

Per stampare come si è visto sopra si usano le funzioni:

System.out.print(string);
System.out.prinln(string);

Ad esempio:

System.out.println("Ciao");
System.out.print("Ciao") // in questo caso non va a capo;

Per richiedere invece un input, si usa la classe Scanner, che vediamo nel seguente esempio:

import java.util.Scanner;
    
public class InputApplication {
    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        System.out.print("Inserisci a: ");
        int a = input.nextInt();
        System.out.print("Inserisci b: ");
        int b = input.nextInt();
        int c = a + b;
        System.out.println("La somma è: " + c);
        input.close();

    }
}

Cose da osservare:

• importare la classe Scanner;
• bisogna istanziare un oggetto della classe Scanner (vedremo più avanti la programmazione ad oggetti);
• scanner contiene un metodo per ogni tipo di dato (nextInt, nextString, ecc.);
• al termine bisogna chiudere l’input (metodo close() ).

Sintassi

La sintassi di Java prevede le seguenti regole:

– ogni istruzione deve terminare con un ;

int i = 0;

Sono consentiti spazi nelle dichiarazioni di variabile, sono invece obbligatori nelle definizioni di tipo e nell’uso di parole chiave riservate.

– una istruzione può essere sostituita da un blocco:

{     
   int i=0;     
   int j=i+2;
}

Regole di visibilità delle variabili:

• le variabili dichiarate in un blocco non sono visibili anche all’esterno del blocco.
• le variabili dichiarate in un blocco di funzione sono visibili nella funzione ma non all’esterno.
• una variabile dichiarata in un blocco con lo stesso nome di una variabile dichiarata esternamente, la va a sostituire (come simbolo) all’interno del blocco.

Espressioni

Una espressione è una struttura codificata di dati e operatori che viene valutata a runtime.

Essa può essere oggetto di assegnazione o parametro di funzione. L’espressione viene sempre valutata prima del suo utilizzo (ovvero stampa o assegnazione).

Espressioni principali di Java:

– literal: valori numerici o stringhe assoluti. es 1, False, “Ciao”.

– espressioni aritmetiche. Es. “5+4”, “90/2”. Possono essere applicati operatori matematici (+,-,/,*,%, ecc.).

– espressioni stringa: Es. “ciao” + ” Mario”. Possono essere applicati operatori come + (concatenazione).

– espressioni logiche booleane. Es. 5 > 3. Possono essere solo True o False. Possono essere applicati operatori booleani (<, <=, >, >=, !=, ==, !== e !==).

– operatori unari. Es. c++ (incrementa di 1 il valore di c)

– null : indica il valore vuoto.

In Java la conversione di tipo implicita è sempre possibile quando si passa da un tipo di dato che contiene più valori (es. da int a float) ma non il contrario, dove bisogna esplicitare il tipo di dato nella conversione.

int c = 3;
float f = c; // -> diventa 3.0
int k = (int)f; // viene presa solo la parte intera di f

Espressioni logiche

Queste espressioni servono per confrontare due o più valori.

Si applicano a valori numerici Hanno come risultato un bool quindi possono avere valore TRUE o FALSE e vengono chiamati anche CONDIZIONI.

Esempio:

a == b

a < 3

k == 4

c <= 6

Operatori booleani

Permettono di verificare più condizioni insieme (quindi connettono variabili di tipo bool).

Il risultato è di tipo bool quindi TRUE o FALSE.

Espressioni:

le espressioni sono una qualsiasi combinazione di operatori di confronto e booleani. Esse producono un bool quindi TRUE o FALSE

Esempio:

a == b || c == b : vera se a è uguale a b OPPURE c è uguale a b

z < 4 && z > 1  : vera se z è compreso tra 1 e 4 esclusi

(a == 6 || a == 8) && ( b < c) : vera se a è 6 oppure 8 E INOLTRE se b è inferiore a c.

Occorre fare attenzione alle regole di precedenza:

• Prima vengono le parentesi
• Poi vengono gli operatori di confronto
• Infine gli operatori booleani
• Tra i booleani l’ordine è NOT (!), AND (&&), OR (||)

Stampa a schermo

Per eseguire l’output si usa la funzione System.out.println (o print se non si vuole andare a capo).

System.out.println("Ciao");
System.out.print("Ciao") // in questo caso non va a capo;

Costrutti del linguaggio

Il flusso del programma è gestito tramite costrutti che valutano condizioni ed eseguono cicli.

Nota: le parentesi quadre indicano codice opzionale.

Esempi di codice

If

int x = 5;
if (x > 10) {
    System.out.println("x è maggiore di 10");
} else if (x > 0) {
    System.out.println("x è positivo ma ≤ 10");
} else {
    System.out.println("x è zero o negativo");
}

For

for (int i = 0; i < 5; i++) {
    System.out.println("Conteggio: " + i);
}

While

int j = 0;
while (j < 3) {
    System.out.println("j = " + j);
    j++;
}

Do-While

int k = 0;
do {
    System.out.println("k = " + k);
    k++;
} while (k < 2);

Switch

int giorno = 3;
switch (giorno) {
    case 1:
        System.out.println("Lunedì");
        break;
    case 2:
        System.out.println("Martedì");
        break;
    case 3:
        System.out.println("Mercoledì");
        break;
    default:
        System.out.println("Altro giorno");
}

Enum

Java prevede un tipo di dato, che consente di definire un elenco di costanti nella stessa struttura. Ad esempio:

enum Colore {
  Verde,
  Blu,
  Rosso
}

gli enum sono assegnabili a variabili:

Colore myColor = Colore.Giallo;

L’obiettivo è quello di rendere il codice più leggibile, senza usare identificatori numerici.

Inoltre sono utilizzabili in un costrutto Switch:

switch(myColor) {
  case Verde: {
     System.out.println("Verde");
     break;
  }
  case Rosso: {
     System.out.println("Rosso");
     break;
  }
  case Blu: {
     System.out.println("Blu");
     break;
  }

Garbage collector

In C++ quando si crea una variabile con new, questa viene allocata nella memoria heap del processo. Resta al programmatore la responsabilità di cancellare la variabile dalla memoria quando non si usa più. Se non lo fa si genera un memory leak, una porzione di memoria inutilizzabile.

Java rende automatica la cancellazione di oggetti creati con new, grazie ad un meccanismo chiamato Garbage collector, che periodicamente controlla se esistono aree di memoria inutilizzate, e le libera.

Il meccanismo è del tutto trasparente per il programmatore ma è bene conoscerne almeno l’esistenza.

Conclusioni

Java ha una sintassi simile a quella del C/C++ in quanto appartiene alla stessa famiglia. Questo rende la transizione più dolce per chi conosce un altro linguaggio della famiglia.