CIAO! Parliamo di un altro tipo di classi nidificate. Sto parlando di classi locali (classi interne metodo-locali). Prima di addentrarci, dobbiamo innanzitutto ricordare il loro posto nella struttura delle classi nidificate. ![Classi interne in un metodo locale - 2]()
Dal nostro diagramma, possiamo vedere che le classi locali sono una sottospecie delle classi interne, di cui abbiamo parlato in dettaglio nei materiali precedenti . Tuttavia, le classi locali hanno una serie di importanti caratteristiche e differenze rispetto alle ordinarie classi interne. La cosa principale è nella loro dichiarazione: una classe locale è dichiarata solo in un blocco di codice. Molto spesso, questa dichiarazione è all'interno di un metodo della classe esterna. Ad esempio, potrebbe assomigliare a questo:
Dal nostro diagramma, possiamo vedere che le classi locali sono una sottospecie delle classi interne, di cui abbiamo parlato in dettaglio nei materiali precedenti . Tuttavia, le classi locali hanno una serie di importanti caratteristiche e differenze rispetto alle ordinarie classi interne. La cosa principale è nella loro dichiarazione: una classe locale è dichiarata solo in un blocco di codice. Molto spesso, questa dichiarazione è all'interno di un metodo della classe esterna. Ad esempio, potrebbe assomigliare a questo:
public class PhoneNumberValidator {
public void validatePhoneNumber(String number) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
// ...number validation code
}
}
finalal parametro del metodo in modo che assomigli a questo: validatePhoneNumber(final String number). Dopodiché, tutto funzionerà. Questo è un piccolo programma che convalida i numeri di telefono. Il suo validatePhoneNumber()metodo accetta una stringa come input e determina se si tratta di un numero di telefono. E all'interno di questo metodo, abbiamo dichiarato la nostra PhoneNumberclasse locale. Potresti ragionevolmente chiedere perché. Perché esattamente dovremmo dichiarare una classe all'interno di un metodo? Perché non usare una classe interna ordinaria? Vero, avremmo potuto fare ilPhoneNumberclasse una classe interna. Ma la soluzione finale dipende dalla struttura e dallo scopo del tuo programma. Ricordiamo il nostro esempio da una lezione sulle classi interne:
public class Bicycle {
private String model;
private int maxWeight;
public Bicycle(String model, int maxWeight) {
this.model = model;
this.maxWeight = maxWeight;
}
public void start() {
System.out.println("Let's go!");
}
public class HandleBar {
public void right() {
System.out.println("Steer right!");
}
public void left() {
System.out.println("Steer left!");
}
}
}
HandleBaruna classe interna della bici. Qual è la differenza? Prima di tutto, il modo in cui viene utilizzata la classe è diverso. La HandleBarclasse nel secondo esempio è un'entità più complessa rispetto alla PhoneNumberclasse nel primo esempio. Innanzitutto, HandleBarha public righte leftmetodi (questi non sono setter/getter). In secondo luogo, è impossibile prevedere in anticipo dove potremmo averne bisogno e la sua Bicycleclasse esterna. Potrebbero esserci dozzine di luoghi e metodi diversi, anche in un unico programma. Ma con la PhoneNumberclasse, tutto è molto più semplice. Il nostro programma è molto semplice. Ha un solo scopo: controllare se un numero è un numero di telefono valido. Nella maggior parte dei casi, il nostroPhoneNumberValidatornon sarà nemmeno un programma autonomo, ma piuttosto una parte della logica di autorizzazione per un programma più ampio. Ad esempio, vari siti Web richiedono spesso un numero di telefono quando gli utenti si registrano. Se inserisci delle sciocchezze invece dei numeri, il sito web segnalerà un errore: "Questo non è un numero di telefono!" Gli sviluppatori di un tale sito Web (o meglio, il suo meccanismo di autorizzazione dell'utente) possono includere qualcosa di simile al nostroPhoneNumberValidatornel loro codice. In altre parole, abbiamo una classe esterna con un metodo, che verrà utilizzato in un punto del programma e da nessun'altra parte. E se viene utilizzato, non cambierà nulla in esso: un metodo fa il suo lavoro - e basta. In questo caso, poiché tutta la logica è raccolta in un metodo, sarà molto più conveniente e opportuno incapsularvi una classe aggiuntiva. Non ha metodi propri tranne un getter e un setter. In effetti, abbiamo bisogno solo dei dati del costruttore. Non è coinvolto in altri metodi. Di conseguenza, non vi è alcun motivo per prendere informazioni su di esso al di fuori dell'unico metodo in cui viene utilizzato. Abbiamo anche fornito un esempio in cui una classe locale è dichiarata in un metodo, ma questa non è l'unica opzione. Può essere dichiarato semplicemente in un blocco di codice:
public class PhoneNumberValidator {
{
class PhoneNumber {
private String phoneNumber;
public PhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
}
public void validatePhoneNumber(String phoneNumber) {
// ...number validation code
}
}
forgiro!
public class PhoneNumberValidator {
public void validatePhoneNumber(String phoneNumber) {
for (int i = 0; i < 10; i++) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
// ...some logic
}
// ...number validation code
}
}
generatePhoneNumber()metodo che generi un numero di telefono casuale e restituisca un PhoneNumberoggetto. Nella nostra situazione attuale, non possiamo creare un tale metodo nella nostra classe validator:
public class PhoneNumberValidator {
public void validatePhoneNumber(String number) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
// ...number validation code
}
// Error! The compiler does not recognize the PhoneNumber class
public PhoneNumber generatePhoneNumber() {
}
}
String usCountryCodevariabile locale all'interno del validatePhoneNumber()metodo per qualche motivo, possiamo accedervi dalla PhoneNumberclasse locale. Tuttavia, ci sono molte sottigliezze che dipendono dalla versione della lingua utilizzata nel programma. All'inizio della lezione, abbiamo notato che il codice per uno degli esempi potrebbe non essere compilato in Java 7, ricordi? Ora consideriamo le ragioni di ciò :) In Java 7, una classe locale può accedere a una variabile locale o a un parametro di metodo solo se sono dichiarati come finalnel metodo:
public void validatePhoneNumber(String number) {
String usCountryCode = "+1";
class PhoneNumber {
private String phoneNumber;
// Error! The method parameter must be declared as final!
public PhoneNumber() {
this.phoneNumber = number;
}
public void printUsCountryCode() {
// Error! The local variable must be declared as final!
System.out.println(usCountryCode);
}
}
// ...number validation code
}
public void validatePhoneNumber(final String number) {
final String usCountryCode = "+1";
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public void printUsCountryCode() {
System.out.println(usCountryCode);
}
}
// ...number validation code
}
finalparametri del metodo e finalalle variabili locali. In Java 8, il comportamento delle classi locali è cambiato. In questa versione del linguaggio, una classe locale ha accesso non solo a finalvariabili e parametri locali, ma anche a quelli che sono effective-final. Effective-finalè una variabile il cui valore non è cambiato dall'inizializzazione. Ad esempio, in Java 8, possiamo facilmente visualizzare la usCountryCodevariabile sulla console, anche se non è final. L'importante è che il suo valore non cambi. Nell'esempio seguente, tutto funziona come dovrebbe:
public void validatePhoneNumber(String number) {
String usCountryCode = "+1";
class PhoneNumber {
public void printUsCountryCode() {
// Java 7 would produce an error here
System.out.println(usCountryCode);
}
}
// ...number validation code
}
public void validatePhoneNumber(String number) {
String usCountryCode = "+1";
usCountryCode = "+8";
class PhoneNumber {
public void printUsCountryCode() {
// Error!
System.out.println(usCountryCode);
}
}
// ...number validation code
}
String phoneNumberRegexcampo statico alla nostra classe validator:
public class PhoneNumberValidator {
private static String phoneNumberRegex = "[^0-9]";
public void validatePhoneNumber(String phoneNumber) {
class PhoneNumber {
// ......
}
}
}
[^0-9]" (ovvero, qualsiasi carattere che non sia una cifra da 0 a 9). Possiamo facilmente accedere a questa variabile dalla PhoneNumberclasse locale. Ad esempio, scrivi un getter:
public String getPhoneNumberRegex() {
return phoneNumberRegex;
}
public class PhoneNumberValidator {
public static void validatePhoneNumber(String number) {
interface I {}
class PhoneNumber implements I{
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
}
// ...number validation code
}
}
PhoneNumberclasse può implementarla:
public class PhoneNumberValidator {
interface I {}
public static void validatePhoneNumber(String number) {
class PhoneNumber implements I{
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
}
// ...number validation code
}
}
static final). E ora conosci le lezioni locali, gente! Come puoi vedere, hanno molte differenze rispetto alle classi interne ordinarie. Abbiamo anche dovuto approfondire le caratteristiche di versioni specifiche del linguaggio per capire come funzionano :) Nella prossima lezione parleremo delle classi interne anonime — l'ultimo gruppo di classi nidificate. Buona fortuna per i tuoi studi. :)
GO TO FULL VERSION