9. Input dell’utente: la classe Scanner

Andrea Pastore 19/03/2020 0

I programmi che abbiamo visto finora non prevedono l’interazione da parte dell’utente, possono solo essere avviati. Questo è diverso dai programmi reali, che danno la possibilità all’utente di interagire. Cominciamo a vedere la forma più semplice di interazione dell’utente, con dei programmi che saranno in grado di prendere input da tastiera.

Per questo utilizzeremo la classe Scanner, una delle tante classi messe a disposzione da Java per degli scopi specifici. Nel caso della classe Scanner questa è stata creata per consentire a Java di prendere in input dati testuali o numerici. Facciamo un esempio: il codice qui sotto chiede all’utente di scrivere qualcosa con la tastiera e poi stamperà quello che l’utente ha scritto.

import java.util.Scanner;

public class HelloScanner {

public static void main(String[] args) {

  Scanner input = new Scanner(System.in);

  System.out.println("Scrivi qualcosa");

  String s = input.nextLine();

  System.out.println("Hai scritto: "+s);

}

 }

Notiamo che questo programma ha una nuova riga di codice:

import java.util.Scanner;

Quando vogliamo usare una classe messa a disposizione da Java dobbiamo importarla. Faremo la stessa cosa in seguito quando importeremo classi realizzate da noi. Continuiamo l’analisi del nostro programma: vediamo subito dopo una classe e poi un metodo main, che sono cose a noi note. Poi vediamo un’altra riga di codice nuova:

Scanner input = new Scanner(System.in);

con questa riga stiamo creando un oggetto di tipo Scanner. Questa cosa ci sarà più chiara in seguito, per ora prendiamolo come un passaggio necessario per prendere in input questi dati. Proseguendo la lettura del codice troviamo un altro comando a noi noto, quello che ordina a Java di stampare:

System.out.println("Scrivi qualcosa");

Seguito da :

 String s = input.nextLine();

che consente a java di recuperare il testo inserito dall’utente. In sostanza Il programma chiede all’utente di scrivere qualcosa (con il comando precedente) e poi si mette in ascolto: resterà bloccato fino a quando l’utente non avrà scritto qualcosa e premuto invio.

La riga successiva che troviamo

System.out.println("Hai scritto: "+s);

stampa a video ciò che ha scritto l’utente.

 

Recuperare tipi di dati diversi da String

Per la maggior parte del tempo utilizzeremo lo scanner per recuperare stringhe, ma può capitarci di dover recuperare altri tipi di dati ad esempio numeri interi o decimali. In questo caso dovremmo usare il seguente codice:

int n = input.nextInt();		 // recuperiamo un numero intero

double d = input.nextDouble(); // recuperiamo un numero decimale

Nota: questi metodi possono creare dei problemi se subito dopo aver recuperato una numero dobbiamo recuperare una stringa. Se si verifica questa esigenza dobbiamo recuperare una stringa e poi fare la conversione, come mostrato in seguito:

 

	System.out.println("Scrivi un numero");

String s = input.nextLine();

int n    = Integer.parseInt(n);
Potrebbero interessarti anche...

Andrea Pastore 19/03/2020

2. Ambienti di sviluppo

Per ambiente di sviluppo (in inglese IDE – Integrated Development Environment) si intende un software in grado di aiutarci con la scrittura del codice, segnalando errori di sintassi, suggerire il codice che stiamo scrivendo (le funzioni di autocompletamento) e molti altri tool avanzati. Vediamo i principali:

 

Eclipse

Ambiente di sviluppo polivalente sviluppato dalla Eclipse Foundation nel 2004. È uno degli Ide più popolari, non solo per Java, ma anche per il C, php e altro ancora.

 

Netbeans

Ambiente di sviluppo sviluppato da Sun e per i primi tempi ide di riferimento per Java. Quando java è passato ad Oracle ha perso popolarità in favore di Eclipse, recentemente è stato donato alla Apache Foundation.

In questo corso utilizzeremo Eclipse, diamogli quindi un’occhiata più da vicino e vediamo come creare un nuovo progetto, un nuovo package e una nuova classe.

 

Creazione di un progetto in Eclipse

Dal menu file clicco su new e poi su Java Project. Si aprirà una schermata come quella sottostante:

Dobbiamo semplicemente scegliere il nome del nostro progetto ignorando per ora le altre voci, che consentono delle personalizzazioni avanzate che in questa fase non ci interessano.

Creare un package in Eclipse

Sulla sinistra Eclipse visualizza una barra chiamata Package Explorer, con tutti i progetti. Per creare un nuovo package clicchiamo col tasto destro sul nome del progetto, scegliamo new e poi selezioniamo package. Si aprirà questa schermata:

inseriamo il nome del nostro package. Esiste una convenzione per cui il nome di un package comincia sempre con la lettera minuscola, è bene sempre rispettare questo tipo di convenzioni.

 

Creare una classe in Eclipse

Per creare una classe clicchiamo con il tasto destro sul nome del package che la deve contenere, clicchiamo su new e scegliamo class. Apparirà la seguente schermata:

Nel campo name possiamo inserire il nome della classe, che in questo caso deve iniziare con una lettera maiuscola. Questa schermata contiene varie opzioni che utilizzeremo più avanti, per ora ci concentriamo su una opzione, quella che consente di inserire il metodo main. Ogni volta che vogliamo creare una classe main (che ricordiamo è la classe che fa avviare il progetto) dobbiamo spunare la voce

public static void main(String[] args)

le prime classi che creeremo avranno tutte il metodo main

 

Scorciatoie di tastiera di Eclipse

Eclipse come tutti gli ide mette a disposizione diverse scorciatoie di tastiera, la più usata è data dalla combinazione:

ctrl + spazio

che serve ad attivare l’autocompletamento. I comandi in Java possono essere molto lunghi, si prenda ad esempio questo comando che vedremo a breve:

System.out.println("Hello world!")

Scrivendo solo la parola

System.out.pr

e poi usando ctrl + spazio Eclipse ci darà le opzioni per l’autocompletamento.

 

Hello world!

È tradizione iniziare a programmare scrivendo un programma che stampi la scritta:

Hello world!

Il codice di questo programma è il seguente

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello world!");

}

}

Come vediamo questa è una classe con il metodo main, ovvero è una classe che può essere lanciata in esecuzione. Nel metodo main vediamo una riga di codice:

System.out.println("Hello world!")

Il comando System.out.println serve per stampare: in questo caso prende in input la stringa Hello world! Quando dobbiamo scrivere questo comando possiamo usare una scorciatoia di Eclipse, scriviamo solo la parola:

syso

e poi premiamo ctrl + spazio. Eclipse trasformerà quelle quattro lettere in:

System.out.println() 

a quel punto dovremmo solo indicare a Java cosa stampare all’interno delle parentesi tonde.

Leggi tutto

Andrea Pastore 19/03/2020

7. Buone abitudini: indentare il codice

L’indentazione del codice consiste nell’inserire alcuni spazi all’inizio di una riga, ed è usata per aiutare a capire la struttura del codice scritto. Se ad esempio dobbiamo scrivere un if, per indicare il codice da eseguire se la condizione è verificata è buona norma indentare questo codice. Facciamo un esempio, prendiamo questo codice non indentato:

Tutti i caratteri sono scritti uno sotto l’altro e il codice risulta più difficile da leggere. Questo è un codice di poche righe, ma cosa succederebbe se fosse più corposo? Ci costringerebbe a perdere più tempo a capire cosa fa. Vediamo ora un codice ordinato:

Basta una rapida occhiata per capire il codice dove si trova e cosa fa.

 

Le regole dell’indentazione

Dobbiamo indentare il codice delle strutture di controllo (if, switch, for e altri), dei metodi e infine delle classi.

Leggi tutto

Andrea Pastore 19/03/2020

12. Polimorfismo in Java

Alcuni linguaggi di programmazione consentono di decidere il comportamento dei metodi e costruttori in base al numero di variabili che vengono passate loro come parametro.  Supponiamo ad esempio di avere una classe Java chiamata Utente, con tre variabili (id, nome, cognome) e due costruttori: il primo prenderà in input solo una variabile id, il secondo prenderà in input una variabile id, una variabile nome e una variabile cognome.

I due costruttori in java saranno i seguenti

public Utente(int id) {

this.id = id;

this.nome = “”;

this.cognome = “”;

this.email = “”;

}

public Utente(int id, String nome, String cognome) {

this.id = id;

this.nome = nome;

this.cognome = cognome;

}

Quando noi invochiamo il costruttore a seconda del numero di parametri che inseriamo Java userà il costruttore che combacia con i parametri inseriti ed eseguirà il codice contenuto all’interno. Java darà un errore solo se non trova un costruttore con il numeor di parametri da noi specificato. Ad esempio se scriviamo:

	Utente utente =  new Utente(3,”Mario”,”Rossi”,”mario@gmail.com”);

Otterremo un errore, perché non abbiamo definito un costruttore che prende in input quattro parametri. Tutto quello che abbiamo detto per i costruttori è valido anche per i metodi (del resto il costruttore non è altro che un metodo speciale). Prendiamo in esame il seguente metodo che stampa tutti i dati dell’utente:

public void stampaDati() {

System.out.println(this.id + “ ” + this.nome + “ ” + this.cognome + “ ” +this.email);

}

Come per i costruttori possiamo creare un altro metodo che ha lo stesso nome, ma prende in input un parametro per stabilire come devono essere stampati questi elementi. Stabiliamo due tipologie di stampa: essenziale che stampa solo nome e cognome, completa che stampa tutto. Se il parametro passato in input non corrisponde a nessuna di queste due cose allora questo metodo invoca a sua volta il metodo stampaDati senza parametri, che stamperà i dati senza formattazione.

	public void stampaDati(String tipoVisualizzazione) {

if(tipoVisualizzazione.equals("essenziale")) {

System.out.println("Nome:"+this.nome+"; Cognome:"+this.cognome);

}

else if (tipoVisualizzazione.equals("completa")){

System.out.println("Id: "+this.id + "; Nome:"+this.nome+"; Cognome:"+this.cognome+"; Email:"+this.email);

}

else {

stampaDati();

}

}

Ereditarietà

L’ereditarietà è una caratteristica di molti linguaggi di programmazione moderni che consente di ottimizzare il codice scritto ed evitare ripetizioni. Ci sono casi in cui dobbiamo creare classi molto simili tra loro. Per questo molti linguaggi di programmazione consentono di usare il meccanismo dell’ereditarietà. Supponiamo di avere bisogno di questa due classi:

  • Utente
    id, nome, cognome, email,telefono
  • Fornitore
    id, nome, cognome, email,telefono,partitaIva

notiamo che Fornitore è quasi uguale alla classe Utente, quindi non ha senso riscriverla. Quando creiamo la classe Fornitore che estenderà la classe Utente. Scriviamo le due classi per renderci conto del codice e delle differenze tra le due. Qui sotto vediamo la classe utente:

public class Utente {

private int id ;

private String nome;

private String cognome;

private String email;

private String telefono;



public Utente(int id, String nome, String cognome, String email, String telefono) {

this.id = id;

this.nome = nome;

this.cognome = cognome;

this.email = email;

this.telefono = telefono;

}

// Getter & setter

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

… tutti gli altri getter e setter

}

Vediamo ora la classe Fornitore. Come abbiamo capito Java ci consente di evitare di ricopiare la classe, basta dichiarare, al momento della creazione, che la nuova classe estende la classe Utente. Questo avviene con la parola chiave extends.

public class Fornitore extends Utente {

private String partitaIva;

public Fornitore(String partitaIva, int id, String nome, String cognome, String email, String telefono) {

super(id, nome, cognome, email, telefono, via, citta, cap);

this.partitaIva = partitaIva;

}

public String getPartitaIva() {

return partitaIva;

}

public void setPartitaIva(String partitaIva) {

this.partitaIva = partitaIva;

}

}


Notiamo alcune differenze con la classe Utente scritta sopra: innanzitutto vediamo che nel costruttore c’è la parola chiave super, seguita da una serie di parametri. Si tratta dei parametri del costruttore della classe Utente, che viene richiamato con il comando super. Ogni volta che noi estendiamo una classe il costruttore della nuova classe deve richiamare il costruttore della classe che estende. Fornitore estende la classe Utente, quindi il suo costruttore prende in input anche i parametri che richiede il costruttore di Utente, che invocherà con il metodo super().

Nota: quando una classe estende un’altra classe, la classe estesa è definita superclasse

 

Le interfacce in Java

Vediamo ora un altro concetto fondamentale della programmazione: le interfacce, che  servono per standardizzare il codice.

 

Interfacce

Le interfacce vengono utilizzate per definire un tipo di dato e una classe, che però non viene implementato. Vengono definite solo le firme dei metodi che poi saranno implementate in altre classi. Vediamo un esempio di interfaccia:

public interface Libro {

public void stampaLibro();

public void setTitolo(String titolo);

public String getTitolo();

public void setNumeroPagine(int numeroPagine);

public int getNumeroPagine();

}

Per usare una determinata interfaccia dopo il nome della classe dobbiamo usare la parola chiave implements seguita dal nome dell'interfaccia. Appena facciamo questo il nostro ide ci segnalerà che i metodi dell'interfaccia non sono ancora implementati, clicchiamo su add unimplementated methods (potrebbe cambiare a seconda dell’ide usato) e il nostro ide li aggiungerà per noi, dobbiamo solo completarli con il codice all'interno.

In sostanza le interfacce consentono di standardizzare il codice: dueprogrammatori si accordano sui metodi e su come vengono chiamati, e poiai fini dell'interoperabilità delle classi non è importante come vieneimplementato. Nel tempo le implementazioni possono cambiare, ma rispettandole interfacce non ci saranno problemi di incompatibilità

 

Il paradigma MVC

La programmazione ad oggetti è utilizzata nel paradigma MVC (MODEL, VIEW, CONTROLLER), che consente una separazione delle logiche. Vediamo i tre elementi nel dettaglio:

  • model
    sono le classi cosi come le abbiamo viste. Quando creiamo una classe infatti definiamo degli oggetti ma non li usiamo in quell’istante
  • view
    le viste rappresentano la parte del progetto che mostra i dati visivamente
  • controller
    sono i file che consentono di rendere permanenti le operazioni sugli oggetti: creazione di nuovi elementi, modifica di elementi esistenti, eliminazione di elementi e anche recupero dei dati di un elemento. I controller nascondono le logiche sottostanti alle altre classi: potremmo voler salvare i dati in un file oppure nel database, per le classi esterne viene chiamato lo stesso metodo. Facendo passare tutte le operazioni di salvataggio, modifica, caricamento per il controller avremo solo una classe che gestisce queste operazioni, che si traduce in un vantaggio per la manutenibilità del codice, in quanto per apportare modifiche alla gestione degli oggetti dovremmo modificare solo la classe relativa.
Leggi tutto

Cerca...