Course Modulo 1 - Lecture: Parole riservate in Java

1. Elenco di parole

Come in qualsiasi linguaggio di programmazione, Java ha parole che hanno un significato speciale. Ad esempio, returno ifo while. Queste parole sono chiamate parole chiave ( keywords ) e sono considerate riservate dal linguaggio Java.

Non è possibile utilizzare queste parole come nome di variabile, nome di metodo o nome di classe. Il compilatore li interpreterà sempre in un modo rigorosamente definito. Ci sono 54parole del genere in Java.

`abstract`	`assert`	`boolean`	`break`	`byte`
`case`	`catch`	`char`	`class`	`const`
`continue`	`default`	`do`	`double`	`else`
`enum`	`extends`	`final`	`finally`	`float`
`for`	`goto`	`if`	`implements`	`import`
`instanceof`	`int`	`interface`	`long`	`native`
`new`	`package`	`private`	`protected`	`public`
`return`	`short`	`static`	`strictfp`	`super`
`switch`	`synchronized`	`this`	`throw`	`throws`
`transient`	`try`	`void`	`volatile`	`while`
`var`	`true`	`null`	`false`

Ne conosci già alcuni e del resto parleremo subito.

2. Tipi primitivi

Come probabilmente ricorderai, Java ha 8 tipi primitivi e ognuno di essi ha la sua parola chiave:

byte
short
int
long
char
float
double
boolean
void

Se hai una mente sufficientemente curiosa, c'è una buona probabilità che tu abbia già provato a nominare una variabile int. E ovviamente non ci sei riuscito. Questo è proprio perché i nomi di tutti i tipi primitivi sono parole riservate.

Anche il voidtipo rientra in questa categoria.

3. Anelli e rami

Cicli e diramazioni ci danno anche un elenco piuttosto lungo di parole chiave:

if
else
switch
case
default
while
do
for
break
continue

Sono sufficienti solo 10 parole affinché il linguaggio fornisca diversi tipi di loop, rami e istruzioni di controllo per interrompere loop ( breake continue) e rami multipli ( switch). Conosci già tutte queste parole chiave.

4. Eccezioni

Le eccezioni ci danno 5 parole chiave:

try
catch
finally
throw
throws

Questi fanno tutti parte di un try-catch-finallyblocco. L'operatore per la generazione delle eccezioni è throwe la throwsparola chiave supporta il checkedmeccanismo delle eccezioni.

La buona notizia è che hai già familiarità con tutte le parole chiave relative alle eccezioni, quindi hai già familiarità con il lavoro con le eccezioni.

5. Visibilità

Qui ci sono solo tre parole chiave e le conosci già.

private
protected
public

publicconsente l'accesso a un metodo/variabile/classe da qualsiasi punto del programma.

privateimpedisce l'accesso a un metodo/variabile/classe da qualsiasi punto del programma. L'accesso è consentito solo all'interno della stessa classe di un metodo contrassegnato con il privatemodificatore.

protectedfunziona come private, ma consente anche l'accesso a un metodo/variabile/classe da classi ereditate. I vantaggi di questo modificatore ti saranno più chiari quando acquisirai familiarità con OOP ed ereditarietà.

6. Lavorare con le classi

Ci sono 11 parole chiave in questa categoria:

class
interface
enum
import
package
extends
implements
static
final
abstract
default

Possono essere divisi in 4 gruppi.

Il primo gruppo si riferisce alla creazione delle classi: class, interfacee enum. Hai già imparato a dichiarare classi ed enum . La interfaceparola chiave è usata per dichiarare ancora un altro tipo simile a una classe: le interfacce.

Il secondo gruppo è costituito dal pacchetto e dalle parole chiave di importazione, che già conosci. La parola chiave package viene utilizzata per specificare il pacchetto di una classe in un file di classe. Ed importè così che possiamo usare nomi brevi di classi esterne quando scriviamo le nostre classi.

Le parole chiave extendse implementsvengono utilizzate per l'ereditarietà. Li darai un'occhiata all'inizio della ricerca Java Core.

Infine, l'ultimo gruppo è costituito dai modificatori static, final, defaulte abstract. Sai già un po' di statice final. La abstractparola chiave viene utilizzata per rendere astratta una classe o un metodo. Otterrai maggiori dettagli studiando l'ereditarietà nella ricerca Java Core.

7. Lavorare con oggetti e variabili

Altre sei parole chiave vengono utilizzate quando si lavora con oggetti, metodi e variabili.

new
instanceof
this
super
return
var(da Java 10)

L' newoperatore viene utilizzato per creare nuovi oggetti, lo sai già.

L' instanceofoperatore viene utilizzato per verificare che una variabile contenga un riferimento a un oggetto di un tipo particolare. Lo conosci già.

La thisparola chiave viene utilizzata per risolvere i problemi che sorgono a causa dell'ombreggiatura di variabili e metodi di istanza. Hai studiato anche questo.

La superparola chiave è analoga a this, ma viene utilizzata per fare riferimento ai metodi e alle variabili della classe genitore. La classe genitore è anche chiamata superclasse.

L' returnistruzione viene utilizzata per restituire il valore di un metodo e anche per terminare l'esecuzione di un metodo.

Infine, varserve per dichiarare una variabile il cui tipo viene dedotto automaticamente. Hai già familiarità con questo.

8. Multithreading

A livello di sintassi Java, il multithreading è rappresentato da due sole parole.

synchronized
volatile

Non li toccheremo nemmeno. Vai alla missione Java Multithreading e poi ci tufferemo.

9. Varie

Ci sono altre 4 parole chiave speciali:

native
transient
assert
strictfp

nativeè un modificatore che può essere scritto prima di una dichiarazione di metodo. Significa che il codice del metodo non è scritto in Java, ma in C++ ed è incorporato nella macchina Java (beh, o una DLL). Come probabilmente avrai già intuito, anche la stessa macchina Java è scritta in C++. Proprio come molti dei metodi di libreria standard.

transientè un modificatore che può essere scritto prima delle variabili di istanza (campi di una classe). Chiede alla macchina Java di saltare (o ignorare) la variabile contrassegnata durante la serializzazione di un oggetto della classe. Puoi saperne di più sulla serializzazione nella ricerca delle raccolte Java.

assertarriva anche a Java da C++. Con il suo aiuto, puoi aggiungere ulteriori controlli al tuo codice (ad esempio, per verificare se una variabile è nulla). La cosa importante qui è che questi controlli siano abilitati o disabilitati in fase di compilazione.

Puoi creare il progetto per test interni e questi controlli verranno eseguiti (inclusi nella build). Oppure puoi disabilitarli durante la compilazione per creare la versione del programma che verrà fornita agli utenti.

Per quanto riguarda la strictfpparola chiave e la precisione extra dei processori Intel, abbiamo tutta una storia per te .

10. Riservato ma non utilizzato

Ci sono anche due parole chiave riservate ma non utilizzate.

const
goto

Questi sono anche un retaggio del linguaggio C++, dove esistono e vengono utilizzati.

11. Non parole chiave

Formalmente, le truecostanti e non sono parole chiave false. nullDetto questo, ognuno ha le sue peculiarità. Non puoi nominare un metodo trueo una variabile false. Il compilatore non capirà tale codice e non lo compilerà.