Java: concetti essenziali

Cicli iterativi in Java

Il ciclo while terminerà quando la condizione i <= 10 risulterà falsa. In questo caso, ciò avverrà quando i avrà valore 11.

A volte, però, un blocco di codice deve essere eseguito perennemente, come nel caso di controlli che devono essere eseguiti costantemente. In questo caso, si pone manualmente il valore true tra parentesi.

Esempio:

while (true) {
    // all'infinito ..blocco di codice...
}

Il ciclo do..while ripete un blocco di codice fintanto che la condizione, valutata al termine dell'esecuzione del blocco, risulta vera.

Esempio:

do {
    // postcondizionato ...blocco di codice...
} while (condizione);

Il ciclo terminerà

ciclo for. L'istruzione continue permette di uscire da un'iterazione del ciclo e passare direttamente alla prossima eventuale iterazione. Esempio:

for (i = 0; i <= 10; i++) {
  if (i == 8) {
    continue;
  }
  System.out.println(i);
}

In questo esempio, quando il contatore i vale 8 si passerà all'iterazione successiva senza eseguire completamente il blocco di codice presente nel ciclo.

Casting. Il casting è l'operazione di conversione del tipo di dato di una variabile. In Java abbiamo due tipi di casting:

• Casting implicito (svolto automaticamente). Avviene quando si converte un tipo in un altro tipo con dimensioni maggiori, con riferimento alla seguente scaletta in ordine crescente: Casting byte -> short -> char -> int -> long -> float -> double.
• Casting esplicito (svolto manualmente). Avviene quando si converte un tipo in un altro tipo con dimensioni minori, con riferimento alla seguente scaletta in ordine decrescente: double -> float

1. Il casting implicito, anche detto Widening Casting, viene svolto automaticamente dalla JVM, come nel seguente esempio:

public class Prova {
    public static void main(String[] args) {
        int x = 10;
        double numeroDouble = x;
        
        // Casting implicito: int -> double
        System.out.println(x); // stampa 10
        System.out.println(numeroDouble); // Outputs 10.0
    }
}

2. Il casting esplicito, anche detto Narrowing Casting, viene svolto manualmente specificando tra parentesi il tipo in cui vogliamo convertire la nostra variabile, come nel seguente esempio:

public class Prova {
    public static void main(String[] args) {
        double decimale = 10.32;
        
        // Casting esplicito: double -> int
        int intero = (int) decimale;
        
        System.out.println(decimale); // Stampa 10.32
        System.out.println(intero); // Stampa 10
    }
}

Metodi

Un metodo Java è un blocco di codice che permette di svolgere un particolare task.

I vantaggi principali dei metodi sono:

variabile eta, è accessibile solo all'interno della classe in cui è definita.

public void saluta() { }

La keyword "public" indica che l'elemento, in questo caso il metodo saluta(), è accessibile da qualsiasi parte del programma.


protected int nominativo;

Modificatori di accesso La keyword "protected" indica che l'elemento, in questo caso la variabile nominativo, è accessibile solo all'interno del package in cui è definita e quindi anche da eventuali sottoclassi.

Esempio di definizione metodo:

public void saluta() {
    System.out.println("Ciao!");
}

Come invocare Esempio di invocazione metodo:

un metodo saluta();

Come puoi notare, per invocare un metodo la sintassi è la seguente: nome_metodo();

Un metodo Java può avere dei parametri, i cui nomi vengono specificati nella sua definizione.
La sintassi è la seguente:

I metodi nome_metodo(parametro1, parametro2, parametroN) {

I parametri

Esempio:

//DEFINIZIONE METODO
metodi salutaPersona(nome) {
    System.out.println("Ciao " + nome + " :)");
}
// INVOCAZIONE METODO
salutaPersona("Pippo");

Esempio:

//DEFINIZIONE METODO
salutaPersona(nome) {
    // I metodi
    System.out.println("Ciao " + nome + " :)");
}
// INVOCAZIONE MULTIPLA METODO
salutaPersona("Pippo");
salutaPersona("Pluto");
salutaPersona("Topolino");

Esempio:

//DEFINIZIONE METODO CON PIU' PARAMETRI
somma(x, y) {
    // I metodi
    int s = x + y;
    System.out.println(x + " + " + y + " = " + s);
    // I parametri
}
// INVOCAZIONE METODO
somma(4, 6);

Un metodo può avere uno statement di return per ritornare un valore a chi ha invocato il metodo. Il return è particolarmente utile quando vengono eseguite operazioni che portano ad un risultato che deve essere riutilizzato durante l'esecuzione del programma. Quando Java

raggiunge un’ istruzione di return, siIl return interrompe l’esecuzione della metodo corrente e sicomunica al chiamante il valore di return.

Esempio:Calcoliamo il prodotto di due numeri, x e y, e ritorniamo ilrisultato.

//DEFINIZIONE metodo
public int prodotto(x,y) {
    return x * y;
}//INVOCAZIONE metodo
int p = prodotto(8,5);//p assume il valore di ritorno della metodo prodotto (40)

Il return viene tipicamente inserito in fondo al blocco di codice del metodo, al termine dei calcoli svolti.

Il nulltype è un tipo di dato particolare che ammette solo il valore null. Con la parola chiave null stiamo specificando l’assenza di particolari valori assegnati a quel particolare oggetto e null viene quindi utilizzato come una specie di “segnaposto”.

Esempio:Nulltype esame = null; //esame non ancora svolto

Enumerazioni Un’ enumerazione, anche detta enum, è un tipo di dato che rappresenta una collezione di costanti.

I nomi

delle costanti dell'enumerazione Enumerazioni vengono scritti in maiuscolo uno dopo l'altro separati da una virgola.

Introduzione Possiamo definire un'enumerazione sia fuori che dentro una classe.

enum Mode {
  EASY,
  NORMAL,
  HARD
}

enum Giochi {
  BILIARDO,
  RISIKO,
  MONOPOLY
}

L'accesso alle costanti dell'enum avviene mediante il punto.

Mode modalitaPartita = Mode.HARD;

Enumerazioni Possiamo anche accedere ciclicamente all'intera enum grazie al metodo values():

for (Mode modalitaPartita : Mode.values()) {
  System.out.println(modalitaPartita);
}

Array Un array è un oggetto particolare in cui possono essere memorizzati più valori. Questo è molto utile nel caso di notevoli quantità di dati.

Per definire un array, aggiungiamo le parentesi quadre Array al tipo di variabile. La sintassi per la dichiarazione è la seguente:

tipo[] nome_array;

Per inizializzare l'array invece scriviamo:

nome_array = { valore1, valore2, valore3, ... };

Ciascun elemento di un array è caratterizzato da un valore e da un indice numerico [I] che ne rappresenta la posizione.

Per accedere ai valori di un array utilizziamo la seguente sintassi:

Array nome_array[indice];

Esempio:

String[] nomi = {"Pippo", "Pluto", "Paperino"};
String nome = nomi[0];
nomi[1] = "Topolino";

In un array, il primo elemento viene inserito nella posizione 0. Il secondo elemento in posizione 1, e così via.

Ad esempio:

int[] arr = {2,4,6};
System.out.println(arr[1]);

Mostra il secondo elemento (perché l'indice parte da 0).

Se tentiamo di accedere ad un elemento specificando una posizione non presente nell'indice, otterremo un'eccezione di runtime dal compilatore: ArrayIndexOutOfBoundsException.

Esempio:

int[] arr = {2,4,6};
System.out.println(arr[8]); //viene sollevata un'eccezione

È possibile anche dichiarare