Modificatori di metodo

Un frammento di lezione con un mentore come parte del corso Codegym University. Iscriviti al corso completo.

"Saluti, Amigo! Ho sentito che conosci già bene i metodi?"

"Ciao, Rishi. Sì, mi sono già fatto strada attraverso il trucco di quell'insegnante. Direi che non è stato poi così male, ma mi dirai: 'No, no! Non hai capito niente. '"

"È chiaro che hai passato troppo tempo a chiacchierare con certi insegnanti, probabilmente con Diego. Comunque... spero ancora che tu capisca abbastanza bene i metodi. Dopotutto, oggi ti insegnerò alcune parole magiche che aiutano a delineare i metodi ' sfere di influenza."

"Sembra intrigante."

"In effetti, è tutto semplice. Prima di ogni metodo, i programmatori possono specificare i cosiddetti modificatori di accesso. Questi includono le seguenti parole chiave: public, protected, private.

"Questi modificatori di accesso ti consentono di limitare l'accesso di altre classi a un metodo.

"Ad esempio, se scrivi la privateparola chiave prima di una dichiarazione di metodo, il metodo può essere chiamato solo dalla stessa classe in cui è dichiarato. La publicparola chiave consente l'accesso al metodo contrassegnato da qualsiasi metodo di qualsiasi classe.

Ci sono un totale di 3 tali modificatori, ma ci sono 4 tipi di accesso a un metodo. Questo perché anche l'assenza di un modificatore di accesso significa qualcosa. Ecco una tabella completa:

"Ed ecco una spiegazione completa dei modificatori di accesso:

1. publicmodificatore

publicÈ possibile accedere a un metodo (o variabile o classe) contrassegnato con il modificatore da qualsiasi punto del programma . Questo è il più alto grado di apertura: non ci sono restrizioni.

2. privatemodificatore

privateÈ possibile accedere a un metodo (o variabile o classe) contrassegnato con il modificatore solo dalla stessa classe in cui è dichiarato . Per tutte le altre classi, il metodo contrassegnato (o la variabile) è invisibile. È come se non esistesse. Questo è il livello più alto di restrizione, solo la sua classe.

3. Nessun modificatore (modificatore predefinito)

Se un metodo (o una variabile) non è contrassegnato da alcun modificatore, si considera che abbia il "modificatore predefinito". Le variabili oi metodi con quel modificatore (cioè senza nessuno) sono visibili a tutte le classi nel pacchetto in cui sono dichiarati . E solo a loro. Questo modificatore è talvolta chiamato anche package-private, suggerendo che l'accesso a variabili e metodi è aperto all'intero pacchetto in cui si trova la loro classe.

4. protectedmodificatore

Se un metodo è contrassegnato con il protectedmodificatore, è possibile accedervi dalla stessa classe, dallo stesso pacchetto e dai discendenti (classi che ereditano la classe in cui è dichiarato il metodo). Analizzeremo questo argomento in modo più dettagliato nella ricerca Java Core."

"Interessante, ma non sono sicuro di poter inserire immediatamente questi modificatori nei posti giusti.

"Ci arriverai gradualmente. Non c'è bisogno di preoccuparsi in anticipo. Fino a quando non raggiungi la fine della ricerca sulla sintassi Java, puoi usare il publicmodificatore su tutti i tuoi metodi (così come classi e variabili di istanza). Avrai bisogno del altri modificatori quando iniziamo a imparare attivamente OOP."

"Puoi spiegare più in dettaglio perché sono necessari i modificatori di accesso?"

"Diventano necessari per grandi progetti scritti da decine e centinaia di programmatori contemporaneamente.

"A volte ci sono situazioni in cui un programmatore vuole dividere un metodo eccessivamente grande in parti e spostare parte del codice in metodi di supporto. Ma allo stesso tempo, non vuole che altri programmatori chiamino questi metodi di supporto, perché il codice corrispondente potrebbe non funzionare correttamente."

"Quindi hanno inventato questi modificatori di accesso. Se contrassegni un metodo di supporto con la parola private , nessun codice diverso dalla tua classe può vedere il tuo metodo di supporto."

"Penso di capire."

staticparola chiave

"C'è un'altra parola chiave interessante. È static. Non sorprende che renda i metodi statici."

"Che cosa significa?"

"Te ne parlerò meglio più tardi. Non preoccuparti. Per ora, cerca solo di ricordare un paio di fatti sui metodi statici.

Fatto 1. Un metodo statico non è collegato ad alcun oggetto, ma appartiene invece alla classe in cui è dichiarato. Per chiamare un metodo statico, devi scrivere:

ClassName.MethodName()

Esempi di metodi statici:

Il nome della classe prima del nome di un metodo statico può essere omesso se si chiama il metodo statico dall'interno della sua classe. Questo è il motivo per cui non è necessario scrivere Solutionprima dei nomi di ciascuno dei metodi statici che vengono chiamati.

Fatto 2. Un metodo statico non può accedere ai metodi non statici della propria classe. Un metodo statico può accedere solo a metodi statici. Di conseguenza, dichiariamo tutti i metodi che vogliamo chiamare dal mainmetodo static."

"Perché?"

"Risponderai tu stesso a questa domanda quando inizierai a imparare l'OOP e capirai come funzionano i metodi statici. Fino ad allora, fidati di me.

throwsparola chiave

"C'è un'altra parola chiave che probabilmente hai visto in una dichiarazione di metodo: la throwsparola chiave. A differenza dei modificatori di accesso e della staticparola chiave, questa parola chiave viene posizionata dopo i parametri del metodo:

public static Type name(parameters) throws Exception
{
  method body
}

"E cosa significa?"

"Ancora una volta devo dirti che imparerai il suo vero scopo in seguito, quando studieremo le eccezioni (nel Livello 15).

Ma per toccarlo superficialmente, possiamo dire che un metodo contrassegnato con la throwsparola chiave può generare errori (eccezioni), ovvero istanze della Exceptionclasse (e classi che la ereditano). Se in una classe possono verificarsi diversi tipi di errori, è necessario elencarli ciascuno separato da virgole."

"Sembra misterioso e incomprensibile! Dovrò aspettare il livello 14."

metodo principale

"Diamo ora un'occhiata più da vicino al metodo principale. Capisci già che la riga in cui è dichiarato un metodo, che contiene tutti i modificatori, influenzerà il modo in cui questo metodo viene chiamato da altre classi e metodi. Inoltre, influisce sul tipo di risultato che il metodo restituirà e indica quali errori sono possibili durante l'esecuzione.

"Tale riga è chiamata dichiarazione di metodo e ha il seguente formato generale:

access modifier static Type name(parameters) throws exceptions

Dove access modifiersè sostituito da public, protected, privateo niente;

se il metodo è statico, staticappare la parola chiave (è assente per i metodi non statici)

Typeè il tipo del valore restituito ( voidse non ci sono risultati)

"Ora hai una comprensione molto migliore di cosa significano tutte queste parole nella dichiarazione del mainmetodo:

public static void main(String[] args) throws Exception

"Bene, ora mi rendo conto che l'accesso al main()metodo è possibile da qualsiasi classe, come indicato dalla publicparola chiave. Il metodo è statico, quindi può essere chiamato esplicitamente come Solution.main()."

"Che risultato main()restituisce il metodo?"

"Nessuno! Il tipo di risultato è void. È un po' come un tipo vuoto, un segnaposto."

"Cosa c'è main()tra parentesi?"

"Hmm... Si scopre che il mainmetodo accetta argomenti (!). Vengono passati come un array di stringhe."

"Esatto. E il nome del parametro argssuggerisce 'argomenti' alle nostre menti. Quando il programma si avvia, puoi passargli degli argomenti — un array di stringhe. Saranno contenuti nell'array argsnel main()metodo."

"Whoa! Me lo sono chiesto quando l'ho visto la prima volta, ma poi mi ci sono abituato e ho iniziato a scrivere l'elenco dei parametri senza pensarci."

"Ci siamo passati tutti. Infine, errori non gestiti come Exception(o suoi discendenti) possono verificarsi nel main()metodo. Lo sappiamo grazie alla throws Exceptionparte della dichiarazione."

"Grazie, Rishi. Non ho capito tutto, ma è stato interessante."

"Prego. A poco a poco capirai tutti questi punti sottili, ne sono sicuro."