|
Di seguito tutte le argomentazioni ufficiali
su cui l'esame verte:
Section
1: Declarations, Initialization and Scoping
Sviluppare un codice che dichiari classi (incluse le
classi astratte e tutte le forme di classi annidate),
interfacce ed enumeratori e includa l'utilizzo corretto
delle istruzioni package e import (incluse le importazioni
statiche).
Sviluppare un codice che dichiari un'interfaccia. Sviluppare
un codice che implementi o estenda una o più
interfacce. Sviluppare un codice che dichiari una classe
astratta. Sviluppare un codice che estenda una classe
astratta.
Sviluppare un codice che dichiari, inizializzi e utilizzi
le primitive, gli array, gli enumeratori e gli oggetti
come variabili statiche, di istanza e locali. Utilizzare
identificatori corretti per i nomi delle variabili.
Sviluppare un codice che dichiari metodi sia statici
che non statici e, se appropriato, utilizzare nomi per
i metodi conformi agli standard di denominazione JavaBeans.
Sviluppare inoltre un codice che dichiari e utilizzi
un elenco di argomenti di lunghezza variabile.
Dato un esempio di codice, determinare se un metodo
sta eseguendo un override o un overload corretto di
un altro metodo e identificare i corretti valori restituiti
(incluse le restituzioni covarianti) per il metodo.
Dato un insieme di classi e superclassi, sviluppare
i costruttori per una o più classi. Data una
dichiarazione di classe, stabilire se verrà creato
il costruttore predefinito e, in tal caso, specificare
il comportamento di quel costruttore. Dato il listato
di una classe annidata (o non annidata) scrivere il
codice appropriato per istanziare la classe.
Section
2: Flow Control
Sviluppare un codice che utilizzi le istruzioni if o
switch e identificare i tipi di argomenti consentiti
per tali istruzioni.
Sviluppare un codice che implementi tutte le forme di
cicli e iteratori, inclusi il ciclo for, il ciclo for
esteso (for-each) e le istruzioni do, while, labels,
break e continue. Specificare i valori assegnati alle
variabili del contatore del ciclo durante e dopo la
sua esecuzione.
Sviluppare un codice che utilizzi le asserzioni e specificare
l'utilizzo appropriato o inappropriato delle asserzioni.
Sviluppare un codice che utilizzi le eccezioni e le
clausole di gestione delle eccezioni (try, catch, finally)
e dichiari metodi e metodi di override che producono
eccezioni.
Riconoscere l'effetto di un'eccezione che si presenta
al punto specificato in un frammento di codice. Si noti
che si può trattare di eccezioni runtime, eccezioni
checked o errori.
Riconoscere le situazioni che producono le seguenti
eccezioni: ArrayIndexOutOfBoundsException,ClassCastException,
IllegalArgumentException, IllegalStateException, NullPointerException,
NumberFormatException, AssertionError, ExceptionInInitializerError,
StackOverflowError o NoClassDefFoundError. Specificare
quali eccezioni vengono prodotte dalla virtual machine
e specificare le situazioni in cui è necessario
programmare l'emissione di altre eccezioni.
Section
3: API Contents
Sviluppare un codice che utilizzi le classi wrapper
primitive (ad es. Boolean, Character, Double, Integer,
ecc.), e/o l'autoboxing e unboxing. Discutere le differenze
tra le classi String, StringBuilder e StringBuffer.
Dato uno scenario che richiede la navigazione dei file
system e la lettura/scrittura di file o l'interazione
con l'utente, sviluppare la soluzione corretta usando
le seguenti classi (anche in combinazione) di java.io:
BufferedReader, BufferedWriter, File, FileReader, FileWriter,
PrintWriter e Console.
Sviluppare un codice che serializzi o deserializzi gli
oggetti usando le seguenti API di java.io: DataInputStream,
DataOutputStream, FileInputStream, FileOutputStream,
ObjectInputStream, ObjectOutputStream e Serializable.
Usare le API standard di J2SE nel pacchetto java.text
per formattare o analizzare in modo corretto i valori
numerici, le date e le valute per una specifica versione
locale. Dato uno scenario, determinare i metodi appropriati
da utilizzare per usare la versione locale predefinita
o una versione locale specifica. Descrivere la funzione
e l'utilizzo della classe java.util.Locale.
Scrivere un codice che utilizzi le API standard di J2SE
incluse nei pacchetti java.util e java.util.regex per
formattare o analizzare stringhe o flussi. Per le stringhe,
scrivere un codice che utilizza le classi Pattern e
Matcher e il metodo String.split. Riconoscere e utilizzare
i modelli di espressioni regolari per le ricerche (solo:
. (punto), * (asterisco), + (più), ?, \d, \s,
\w, [], ()). L'utilizzo di *, + e ? si limiterà
ai quantificatori greedy mentre l'operatore parentesi
verrà usato solo per il raggruppamento (e non
per catturare il contenuto dei match). Per i flussi,
scrivere un codice che utilizzi le classi Formatter
e Scanner e i metodi PrintWriter.format/printf. Riconoscere
e utilizzare i parametri di formattazione (limitandosi
a: %b, %c, %d, %f, %s) nelle stringhe di formato.
Section
4: Concurrency
Scrivere un codice per definire, istanziare e avviare
nuovi thread usando sia java.lang.Thread che java.lang.Runnable.
Riconoscere gli stati in cui può esistere un
thread e identificare i metodi con cui un thread può
passare da uno stato all'altro.
Dato uno scenario, scrivere un codice che utilizzi in
modo appropriato il blocco degli oggetti per proteggere
le variabili statiche o di istanza dall'accesso contemporaneo.
Dato uno scenario, scrivere un codice che utilizzi in
modo appropriato wait, notify o notifyAll.
Section
5: OO Concepts
Sviluppare un codice che implementi l'incapsulamento
stretto (tight), l'accoppiamento debole (loose) e la
coesione elevata nelle classi, e descriverne i benefici.
Dato uno scenario, sviluppare un codice che dimostri
l'utilizzo del polimorfismo. Determinare inoltre quando
sarà necessario il casting e riconoscere gli
errori del compilatore da quelli runtime in relazione
al casting dei riferimenti agli oggetti.
Spiegare l'effetto dei modificatori sull'ereditarietà
in relazione ai costruttori, alle variabili di istanza
o statiche e ai metodi di istanza o statici.
Dato uno scenario, sviluppare un codice che dichiari
e/o invochi metodi overloaded e un codice che dichiari
e/o richiami i costruttori di superclasse o overloaded.
Sviluppare un codice che utilizzi le relazioni "is-a"
e/o "has-a".
Section
6: Collections / Generics
Dato uno scenario di progettazione, determinare quali
classi o interfacce di collezione dovrebbero essere
usate per implementarlo in modo appropriato, incluso
l'utilizzo dell'interfaccia Comparable.
Indicare le differenze tra gli override corretti e non
corretti dei metodi hashCode e equals, e spiegare la
differenza tra == e il metodo equals.
Scrivere un codice che utilizzi le versioni generiche
dell'API Collections, in particolare le classi di implementazione
e le interfacce Set, List e Map. Riconoscere i limiti
dell'API Collections non generica e spiegare come rifattorizzare
il codice in modo da utilizzare le versioni generiche.
Scrivere codice che utilizzi le interfacce NavigableSet
e NavigableMap.
Sviluppare un codice che utilizzi in modo appropriato
i parametri di tipo nelle dichiarazioni delle classi
e delle interfacce, nelle variabili di istanza, negli
argomenti dei metodi e nei tipi di restituzioni. Scrivere
alcuni metodi generici che utilizzano i tipi wildcard
e indicare le differenze e le analogie tra questi due
approcci.
Utilizzare le funzionalità del pacchetto java.util
per scrivere un codice che gestisca un elenco ordinandolo,
eseguendo una ricerca binaria o convertendo l'elenco
in un array. Utilizzare le funzionalità del pacchetto
java.util per scrivere un codice che gestisca un array
ordinandolo, eseguendo una ricerca binaria o convertendo
l'array in un elenco. Utilizzare le interfacce java.util.Comparator
e java.lang.Comparable per modificare l'ordinamento
degli elenchi e degli array. Inoltre, specificare l'effetto
dell'"ordinamento naturale" delle classi wrapper
primitive e di java.lang.String sull'ordinamento.
Section
7: Fundamentals
Dato un esempio di codice e uno scenario, scrivere un
codice che utilizzi i modificatori di accesso, le dichiarazioni
package e le istruzioni import appropriate per interagire
(tramite l'accesso o l'ereditarietà) con il codice
dell'esempio.
Dato un esempio di classe e una riga di comando, determinare
il comportamento atteso al runtime.
Determinare l'effetto sui riferimenti agli oggetti e
sui valori primitivi quando questi vengono passati a
metodi che eseguono un'assegnazione o altre operazioni
di modifica sui parametri.
Dato un esempio di codice, specificare il punto in cui
un oggetto diventa selezionabile per la garbage collection,
determinare cosa è o non è garantito dal
sistema di garbage collection e riconoscere i comportamenti
del metodo Object.finalize().
Dato il nome completamente qualificato di una classe
distribuita all'interno o all'esterno di un file JAR,
creare la struttura di directory appropriata per tale
classe. Dato un esempio di codice e un percorso classpath,
determinare se il percorso classpath consentirà
la corretta compilazione del codice.
Scrivere un codice che applichi in modo corretto gli
operatori appropriati inclusi gli operazioni di assegnazione
(limitandosi a: =, +=, -=), quelli aritmetici (limitandosi
a: +, -, *, /, %, ++, --), gli operatori relazionali
(limitandosi a: <, <=, >, >=, ==, !=), l'operatore
instanceof, quelli logici (limitandosi a: &, |,
^, !, &&, ||) e l'operatore condizionale ( ?
: ) per produrre il risultato desiderato. Scrivere un
codice che determini l'uguaglianza di due oggetti o
due primitive.
- Corso
Programmatore Java
- Calendario
Sessioni Esame
- Prenota
il tuo Esame
- Importanza
della Certificazione
|
