Java 11 - Nuove Funzionalità

Ciao là, futuri programmatori Java! Sono entusiasta di essere il tuo guida in questo emozionante viaggio nel mondo di Java 11. Come qualcuno che ha insegnato scienze informatiche per molti anni, ho visto innumerevoli studenti passare da principianti assoluti a programmatori fiduciosi. Quindi, non preoccuparti se stai iniziando da zero - prenderemo tutto passo per passo, e prima di capirete, scriverete codice Java come un professionista!

Dichiarazioni di Controllo in Java

Iniziamo con le basi. Le dichiarazioni di controllo sono come i semafori della programmazione - dirigono il flusso del tuo codice. In Java 11, abbiamo alcuni modi intelligenti per controllare l'esecuzione del nostro programma.

Dichiarazioni If-Else

La dichiarazione if-else è probabilmente la struttura di controllo più comune che userai. È come prendere una decisione nella vita reale. Ecco un esempio semplice:

int età = 18;
if (età >= 18) {
System.out.println("Puoi votare!");
} else {
System.out.println("Mi dispiace, sei troppo giovane per votare.");
}

In questo codice, stiamo controllando se la variabile età è maggiore o uguale a 18. Se lo è, stampiamo che la persona può votare. Altrimenti, gli diciamo che è troppo giovane. È così semplice!

Dichiarazioni Switch

Le dichiarazioni switch sono fantastiche quando hai molte condizioni da controllare. Pensa a esso come un modo più efficiente per scrivere più dichiarazioni if-else. Java 11 ha introdotto alcuni miglioramenti interessanti alle dichiarazioni switch. Ecco un esempio:

String giorno = "Lunedì";
switch (giorno) {
case "Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì" -> System.out.println("Giorno feriale");
case "Sabato", "Domenica" -> System.out.println("Weekend");
default -> System.out.println("Giorno non valido");
}

Questa dichiarazione switch controlla la variabile giorno e stampa se è un giorno feriale o weekend. La sintassi con la freccia (->) è nuova in Java 11 e rende il codice più conciso.

Programmazione Orientata agli Oggetti (OOP)

La Programmazione Orientata agli Oggetti (OOP) è un concetto fondamentale in Java. È come costruire con i mattoni LEGO - crei diversi oggetti che interagiscono tra loro per formare il tuo programma.

Classi e Oggetti

Una classe è come un progetto per creare oggetti. Ecco una semplice classe che rappresenta una macchina:

public class Auto {
String marca;
String modello;
int anno;

public void avviaMotore() {
System.out.println("Vroom! La " + anno + " " + marca + " " + modello + " si sta avviando.");
}
}

Ora, creiamo un oggetto da questa classe:

Auto miaAuto = new Auto();
miaAuto.marca = "Toyota";
miaAuto.modello = "Corolla";
miaAuto.anno = 2021;
miaAuto.avviaMotore();

Quando esegui questo codice, stamperà: "Vroom! La 2021 Toyota Corolla si sta avviando."

Classi Incorporate in Java

Java arriva con un ricco set di classi incorporate che rendono la nostra vita più facile. Ecco alcune di esse:

Classe String

La classe String viene utilizzata per manipolare il testo. Ecco un esempio:

String saluto = "Ciao, Mondo!";
System.out.println(saluto.length());  // Stampa: 13
System.out.println(saluto.toUpperCase());  // Stampa: CIAO, MONDO!

Classe ArrayList

ArrayList è un array dinamico che può crescere o restringersi secondo necessità:

import java.util.ArrayList;

ArrayList<String> frutti = new ArrayList<>();
frutti.add("Mela");
frutti.add("Bанana");
frutti.add("Ciliegia");
System.out.println(frutti);  // Stampa: [Mela, Bанana, Ciliegia]

Gestione dei File in Java

La gestione dei file è fondamentale per leggere da e scrivere in file. Java 11 ha introdotto nuovi metodi per rendere questo più facile:

import java.nio.file.Files;
import java.nio.file.Path;

String contenuto = "Ciao, Java 11!";
Path percorsoFile = Path.of("esempio.txt");
Files.writeString(percorsoFile, contenuto);

String lettoContenuto = Files.readString(percorsoFile);
System.out.println(lettoContenuto);  // Stampa: Ciao, Java 11!

Questo codice scrive una stringa in un file e poi la legge. I metodi writeString e readString sono nuovi in Java 11 e rendono l'input/output dei file molto più semplice.

Errori e Eccezioni in Java

Errori e eccezioni sono come buche e dossi sulla strada della programmazione. Java ci aiuta a gestirli con grazia:

try {
int risultato = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Oops! Non puoi dividere per zero.");
} finally {
System.out.println("Questo viene sempre eseguito, errore o meno.");
}

Questo codice tenta di dividere per zero (cosa che non va in matematica), cattura l'eccezione risultante e stampa un messaggio amichevole invece di bloccarsi.

Multithreading in Java

Il multithreading è come fare il giocoliere - permette al tuo programma di fare più cose contemporaneamente. Ecco un esempio semplice:

class IlMioThread extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Valore " + i);
}
}
}

public class Main {
public static void main(String args[]) {
IlMioThread t1 = new IlMioThread();
IlMioThread t2 = new IlMioThread();
t1.start();
t2.start();
}
}

Questo crea due thread che eseguono contemporaneamente, ciascuno stampando il proprio ID di thread e un valore.

Sincronizzazione in Java

Quando più thread accedono a risorse condivise, dobbiamo sincronizzarli per evitare conflitti. È come avere semafori all'incrocio:

class Contatore {
private int contatore = 0;
public synchronized void incrementa() {
contatore++;
}
public int getContatore() {
return contatore;
}
}

La parola chiave synchronized garantisce che solo un thread alla volta può eseguire il metodo incrementa.

Rete in Java

Java rende facile creare applicazioni di rete. Ecco un semplice server che ascolta le connessioni:

import java.net.*;
import java.io.*;

public class ServerSemplice {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("Il server sta ascoltando sulla porta 8080");
Socket socket = serverSocket.accept();
System.out.println("Client connesso");
}
}

Questo server ascolta sulla porta 8080 e stampa un messaggio quando un client si connette.

Collections in Java

Le collections Java sono come diversi tipi di contenitori per memorizzare oggetti. Ecco alcune di esse:

List

import java.util.*;

List<String> frutti = new ArrayList<>();
frutti.add("Mela");
frutti.add("Bанana");
System.out.println(frutti);  // Stampa: [Mela, Bанana]

Set

Set<Integer> numeri = new HashSet<>();
numeri.add(1);
numeri.add(2);
numeri.add(1);  // Duplicato, non verrà aggiunto
System.out.println(numeri);  // Stampa: [1, 2]

Map

Map<String, Integer> età = new HashMap<>();
età.put("Alice", 25);
età.put("Bob", 30);
System.out.println(età.get("Alice"));  // Stampa: 25

Interfacce in Java

Le interfacce sono come contratti che le classi possono accettare di seguire. Ecco un esempio:

interface Animale {
void fa Rumore();
}

class Cane implements Animale {
public void faRumore() {
System.out.println("Bau!");
}
}

class Gatto implements Animale {
public void faRumore() {
System.out.println("Miao!");
}
}

Both Cane and Gatto implement the Animale interface, agreeing to provide a faRumore method.

Strutture di Dati in Java

Le strutture di dati sono modi di organizzare e memorizzare i dati. Ecco una semplice lista concatenata:

class Nodo {
int dati;
Nodo next;

Nodo(int d) { dati = d; }
}

class ListaConcatenata {
Nodo testa;

public void aggiungi(int dati) {
Nodo nuovo Nodo = new Nodo(dati);
if (testa == null) {
testa = nuovo Nodo;
} else {
Nodo corrente = testa;
while (corrente.next != null) {
corrente = corrente.next;
}
corrente.next = nuovo Nodo;
}
}

public void stampa() {
Nodo corrente = testa;
while (corrente != null) {
System.out.print(corrente.dati + " ");
corrente = corrente.next;
}
System.out.println();
}
}

public class Main {
public static void main(String[] args) {
ListaConcatenata lista = new ListaConcatenata();
lista.aggiungi(1);
lista.aggiungi(2);
lista.aggiungi(3);
lista.stampa();  // Stampa: 1 2 3
}
}

This code implements a simple linked list data structure.

Algoritmi per Collections in Java

Java provides many useful algorithms for working with collections. Here's an example of sorting:

import java.util.*;

List<Integer> numeri = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5));
Collections.sort(numeri);
System.out.println(numeri);  // Stampa: [1, 1, 2, 3, 4, 5, 5, 6, 9]

Java Avanzato

As you progress, you'll encounter more advanced Java concepts. One such concept is lambda expressions, introduced in Java 8 and further improved in Java 11:

List<Integer> numeri = Arrays.asList(1, 2, 3, 4, 5);
numeri.forEach(n -> System.out.println(n * 2));

This code uses a lambda expression to multiply each number by 2 and print it.

Varie in Java

Java 11 introduced several miscellaneous features. One of them is the var keyword for local variable type inference:

var messaggio = "Ciao, Java 11!";
System.out.println(messaggio);

The compiler infers that messaggio is a String.

API e Frameworks in Java

Java has a vast ecosystem of APIs and frameworks. One popular framework is Spring Boot. Here's a simple "Hello World" Spring Boot application:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class HelloWorldApplication {

public static void main(String[] args) {
SpringApplication.run(HelloWorldApplication.class, args);
}

@GetMapping("/")
public String ciao() {
return "Ciao, Mondo!";
}
}

This creates a web application that responds with "Ciao, Mondo!" when you visit the root URL.

Riferimenti alle Classi in Java

Java allows you to get references to classes at runtime. Here's an example:

Class<?> stringClass = String.class;
System.out.println(stringClass.getName());  // Stampa: java.lang.String

Risorse Utili per Imparare Java

Here are some useful resources for learning Java:

1. Oracle's official Java documentation
2. Codecademy's Java course
3. "Head First Java" book
4. Stack Overflow for asking questions

Nuove Funzionalità

Java 11 introduced several new features. Here's a table summarizing some of them:

Feature	Description
Local-Variable Syntax for Lambda Parameters	Allows var in lambda expressions
HTTP Client (Standard)	Standardized HTTP client API
Launch Single-File Source-Code Programs	Run Java source files directly
String Methods	New methods like isBlank(), lines(), strip(), etc.
Files Methods	New methods like readString(), writeString()

That's it for our whirlwind tour of Java 11! Remember, learning to code is like learning a new language – it takes practice, patience, and perseverance. Don't be discouraged if you don't understand everything right away. Keep coding, keep experimenting, and most importantly, keep having fun! Before you know it, you'll be writing complex Java applications and wondering how it all seemed so difficult at first. Happy coding!

Credits: Image by storyset