Modificatori di metodo

1. Modificatori di accesso

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 consentono di limitare l'accesso di altre classi a un metodo.

Ad esempio, se si scrive 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 modificatori di questo tipo, ma ci sono 4 tipi di accesso a un metodo. Questo perché anche l'assenza di un modificatore di accesso significa qualcosa.

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.

Puoi usare il publicmodificatore su tutti i tuoi metodi (così come su tutte le tue classi e variabili di classe) fino a raggiungere la fine della ricerca Java Syntax. Avrai bisogno degli altri modificatori quando inizieremo a imparare attivamente OOP.

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 desidera suddividere un metodo eccessivamente grande in parti e spostare parte del codice in metodi di supporto. Ma allo stesso tempo, lui o lei 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 helper con la parola private , nessun codice diverso dalla tua classe può vedere il tuo metodo helper.

2. staticparola chiave

La staticparola chiave rende statico un metodo. Vedremo cosa significa in seguito. Per ora, ricorda solo un paio di fatti sui metodi statici.

Fatto 1. Un metodo statico non è associato a nessun 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é? Sarai in grado di rispondere tu stesso a questa domanda quando inizierai a imparare l'OOP e capirai come funzionano i metodi statici.

3. 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 inserita dopo i parametri del metodo:

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

Considereremo il suo significato preciso un po' più avanti quando studieremo le eccezioni.

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

4. mainmetodo

La riga in cui viene dichiarato un metodo, che contiene tutti i modificatori, influenzerà il modo in cui questo metodo viene chiamato da altre classi e metodi. Influisce sul tipo di risultato restituito dal metodo 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 probabilmente capisci cosa significano tutte le parole chiave nella dichiarazione del mainmetodo:

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

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().

Il mainmetodo non restituisce alcun risultato. Il tipo restituito è void(nessun tipo).

Il mainmetodo accetta argomenti(!): un array di stringhe. 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 args nel main()metodo.

Errori non gestiti come Exception(o suoi discendenti) possono verificarsi nel main()metodo.