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 private
parola chiave prima di una dichiarazione di metodo, il metodo può essere chiamato solo dalla stessa classe in cui è dichiarato. La public
parola 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.
Accesso da... | ||||
---|---|---|---|---|
Modificatori | Qualsiasi classe | Classe bambino | Il suo pacchetto | La sua classe |
public |
SÌ | SÌ | SÌ | SÌ |
protected |
NO | SÌ | SÌ | SÌ |
nessun modificatore | NO | NO | SÌ | SÌ |
private |
NO | NO | NO | SÌ |
1. public
modificatore
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. private
modificatore
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. protected
modificatore
Se un metodo è contrassegnato con il protected
modificatore, è 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 public
modificatore 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. static
parola chiave
La static
parola 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:
Nome della classe | Nome del metodo statico | |
---|---|---|
Thread.sleep() |
Thread |
sleep() |
Math.abs() |
Math |
abs() |
Arrays.sort() |
Arrays |
sort() |
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 Solution
prima 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 main
metodo 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. throws
parola chiave
C'è un'altra parola chiave che probabilmente hai visto in una dichiarazione di metodo: la throws
parola chiave. A differenza dei modificatori di accesso e della static
parola 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. main
metodo
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
, private
o niente;
se il metodo è statico, static
appare la parola chiave (è assente per i metodi non statici)
Type
è il tipo del valore restituito ( void
se non ci sono risultati)
Ora probabilmente capisci cosa significano tutte le parole chiave nella dichiarazione del main
metodo:
public static void main(String[] args) throws Exception
L'accesso al main()
metodo è possibile da qualsiasi classe, come indicato dalla public
parola chiave.
Il metodo è statico, quindi può essere chiamato esplicitamente come Solution.main()
.
Il main
metodo non restituisce alcun risultato. Il tipo restituito è void
(nessun tipo).
Il main
metodo accetta argomenti(!): un array di stringhe. E il nome del parametro args
suggerisce "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.
GO TO FULL VERSION