cosa è un membro -> un membro è l'insieme di attributi e metodi

cosa è un membro statico -> un membro statico è un membro che non ha bisogno
dell'istanza per funzionare
in un metodo statico a cosa possiamo far riferimento -> solo a attributi statici
definisci information hiding -> incapsulamento, noi che implementiamo sappiamo come
è fatta, e sappiamo che può essere usata anche senza sapere come è implementata
definire il significato di private -> vuol dire che non può essere utilizzato da
tutti coloro che usano il programma, ma ha bisogno di un metodo per accedervi
definire il costruttore -> un metodo pubblico che permette di istanziare una classe
definizione di this. -> fa riferimento all'attributo nell'istanza corrente
definisci la firma di una funzione -> la firma è la struttura di un metodo [tipo
dato restituito, nome metodo, parametri tra parentesi(se ce ne sono)]
definisci l'associazione -> legame tra due classi
cosa è l'aggregazione -> l'aggregazione è l'inserimento degli attributi di una
classe all'interno della classe reggente, associazione binaria di due classi
disegna un'associazione tra due classi
cosa è un diagramma di classi -> è una rappresentazione grafica della struttura
delle classi e il loro legame
cosa sono i metodi assessor -> sono dei metodi di istanza che ci permettono di
leggere o modificare gli attributi di una nostra classe
disegna cosa succede con il costruttore per default
cosa identifica la cardinalità -> identifica il numero massimo e minimo di istanze
che partecipano alla classe reggente
composizione -> associazione più forte aggregazione -> associazione meno forte
overload -> sovracarichiamo un metodo aggiungendo i parametri
se si compila e esegue la toString senza averla, ci da l'indirizzo di memoria

17/10/2023

definisci vettore -> insieme di dati omogenei allocati in memoria in modo contiguo
elenca i controllori di flusso -> while for do-while if switch
cosa è la cardinalità -> è un numero che identifica quante istanze partecipano alla
collezione
differenza tra comp e aggr -> la composozione ha bisogno di un oggetto mentre
laggregazione no(la macchina ha bisogno almeno di 4 ruote)
simboli cardinalità -> ?(0..1) *(0..n) +(1..n)
quali sono le visibilita dei membri di una classe -> pubblico privato
definisci cosa sono gli accessor -> metodi per andare a lavorare sui attributi, per
leggere e scrivere.
insieme di valori dell'oggetto -> stato
definisci i membri statici -> sono dei membri che sono comuni a tutte le istanze
cosa è un serializzatore -> è un metodo che converte lo stato di un'istanza in una
stringa
cosa succede se si richiama il serializzatore senza parametri ->mostra l'indirizzo
in memoria
elenco dei costruttori possibili -> default e per parametro
cosa voul dire shadowing -> lo shadowing succede quando una variabile locale oscura
una variabile globale perchè hanno lo stesso nome
nel momento in cui si dichiara una classe, si crea una istanza statica -> il
costruttore di default
come si richiama un metodo statico -> classe.metodo
i membri statici a quali attributi fanno riferimento -> solo statici
terminatore di una collezione -> -1
cosa si intende per run time enviroment -> è l'ambiente d'esecuzione
null object -> istanza terminatore
differenza tra interprete e macchina virtuale -> ambiente di esecuzione interprete
bycode
primitivi -> dato elementare
indice -> un'indice è un puntatore alla prima cella di una collezione
variabile utilizzato per accedere ad una collezione
definisci il ciclo for -> il ciclo for è un ciclo condizionale composto da una
inizializzazione, una condizione, e l'incremento della variabile contatore
path -> insieme cartelle in cui cercare gli eseguibili
cosa è il kernel -> nocciolo sistema operativo che permette un accesso all'hardware
sicuro
cosa succede quando richiami il costruttore di default -> viene generata un'istanza
con parametri default della classe

24/10/23

come facciamo a generare dei numeri pseudo casuali in java -> si istanzia una
classe chiamata Random, si richiama il metodo nextInt a cui si può dare sia un
valore di inizio(incluso) si un valore di fine (escluso)
simbologia molteplicita -> ? + *
definisci un vettore -> insieme di dati omogenei allocati in memoria in modo
contiguo
come si può definire un membro che si comune a tutte le istanze -> mettendo static
come è possibile dato un vettore conoscerne la sua dimensione -> abbiamo due modi,
il primo è se abbiamo un terminatore, cicliamo fino al terminatore aggiornando una
variabile contatore, o usiamo la vettore.length
cosa sono gli accessor -> sono dei metodi di istanza che vengono utilizzati per
accedere agli attributi (manipolare l'oggetto)
differenza tra aggregazione e composizione ->
deserializzatore -> il deserializzatore è un metodo che viene usato per prendere da
una stringa i valori che vengono istanzianti
definisci un membro statico -> membro comune a tutte le istanze
sovraccarico -> l'overload è il passaggio dei parametri ad un metodo e serve ad
alterare lo stato del metodo
pratica dell'object oriented che consiste nel
cosa è la firma -> la firma identifica un metodo
cosa è una maniglia -> la maniglia è un puntatore all'istanza corrente
come si chiama il puntatore all'istanza corrente -> this
costruttori -> default, per parametri
glasspath -> percorso di cartelle che serve ad
passaggi per ottenere un file compilato da sorgente in java -> la sorgente
(java) viene passato al pseudo compiler, crea il linguaggio intermedio e poi lo
passa all'interprete, ovvero la jum
pseudocodice ->
da che sito scarichi la jdk -> oracle,
cosa è un file .classe è il codice che viene passato all'interprete
shadowing -> etichetta locale oscura l'etichetta globale
cosa è un dato primito -> tipo di dato elementare/fondamentale
membro di istanza -> posso far riferimento a tutti i membri
membro di classe -> fa solo riferimento ai membri statici
definisci variabile locale -> variabile che viene istanziata in un frammento di
codice e che alla fine del frammento viene eliminata
definisci ciclo di vita e scope -> il ciclo di vita determina la durata di una
variabile

--------

stato di una classe ->

differenza tra composizione e aggregazione -> aggr le due classi lavorano
indimpendentemente dall'altra classe, nella composizione una classe non può esiste
senza l'altra
composizione -> le istanze partecipanti hanno bisogno di un legame per esiste
aggregazione -> le istanze posso partecipare anche senza un legame
ereditarieta -> noi creiamo una classe chiamata superclasse con dei attributi che
verranno condivisi dalle sottoclassi che sono la specializzazione della super
classe
concetto di costruttore di default e parametri e come lo richiamiamo in una
sottoclasse ->
costruttore default -> crea un'istanza con dei parmatrei di default (0 per
gli int e null per le stringe)
costruttore per parametri -> crea un'istanza con i parametri scelti
dall'utente
per richiamare i costruttori in una sottoclasse dobbiamo usare il suffisso
super per accedere alla superclasse
concetto di override -> firma uguale e implementazione diversa nelle sottoclassi
riscrivo il metodo con la stessa firma ma con
l'implementazione diversa
binding dinamico ->
overloading -> metodi con firma e implementazione diversa con stesso nome metodo
all'interno di una classe metodi con stesso nome ma firma
diversa
cosa è un metodo statico -> metodo che lavora con attributi statici ed è comune a
tutte le istanze

se gli attributi di una superclasse sono protetti -> le sottoclassi imminenti sono
visibili, mentre le sottoclassi più distanti le vedono private

come accedi ad un metodo di una superclasse -> per accedere ad un metodo di una
sottoclasse bisogna mettere il suffisso super.

serializzatore -> convertire dei parametri in una stringa

trasforma lo stato di un oggetto in una succesione di byte
deserializzatore -> convertire una stringa in parametri
usa una sequenza di byte per creare un istanza

come possiamo creare una sottoclasse partendo da una superclasse -> dobbiamo creare
la sottoclasse con "extends *superclasse*"

cosa si intende per shadowing -> variabile locale oscura l'attributo globale
hanno entrambi stesso nome

assessor -> metodi che ti permetto di accedere agli attributi

sottoclasse può accedere agli attributi della superclasse -> utilizzando gli
accessor

definizione di vettore -> insieme di dati omogenei allocati in memoria in modo

contiguo
arraylist -> insieme di dati omogenei allocati in modo non contiguo

come si confrontano due stringhe -> utilizziamo un metodo comparatore

cosa devi implementare prima di una sort -> una relazione d'ordine

differenza tra dichiarare e implementare -> dichiari una variabile e implementi un

metodo

come si dichiara una costante -> devo usare final e scrivere il nome in maiuscolo

cosa è un'enum -> struttura dati, l'enum è una ridifinizione di un intero presi
come costanti

------------------- 12/12/23 -----------------

a quali membri posso accedere con un metodo statico -> solo a queli statici

definizione di vettore -> insieme di dati allocati in modo contiguo

incapsulamento -> vuol dire celare i membri a colui che utilizzera la classe
lasciandoglieli usare

frammento di classe che utilizza la classe -> client

incapsulamento -> vuol dire celare i membri al client

ho una classe, non sviluppo la toString, ma la chiamo lo stesso, cosa produce ->
mostra sul terminale l'indirizzo di memoria dell'istanza

quali metodi ha la classe arrayList -> for each, add, remove, compare, fetch,
toString

da cosa è composto un'arrayList -> un arrayList è composto da elementi chiamati

oggetti

differenza tra array e arrayList -> i vettori hanno una dimensione statica mentre
l'arrayList è dinamico in base alle necessità della classe

overloading -> due metodi con stesso nome ma firma diversa

override -> stessa firma, implementazione diversa

tutte le possibili visibilita dei membri -> private protected e public

-private -> non può essere modificato direttamente ma bisogna usare dei
metodi appositi (accessor)
-protected -> visibile solo alla superclasse e alle sottoclassi di un livello
inferiore, le altre sottoclassi invece si usano i metodi
accessor
-public ->

significato di visibilità -> la visibilità di un membro è come si può accedere al

membro

parola per la istanza corrente -> this.

perchè dovrei usare privato al posto di protetto in una superclasse -> si usa
protected quando abbiamo bisogno di richiamare gli attributi nella sottolasse e non
vogliamo usare gli accessor

membri di una classe -> i membri sono composti attributi e metodi

come si dichiara un'arrayList -> ArrayList <Studente> studenteList =

new ArrayList<Studente>();

dichiara un array di studenti -> Studenti [] vett = new Studenti [22];

-------- 19/12/23 -----------

specializzazione -> si intende la creazione di una sottoclasse
è possibili in java ereditare da più sottoclassi -> no
come possiamo aggirare -> tramite aggregazione
come faccio a usare i metodi senza poterli avere -> wrapping(stessa firma, )
può esistere una sottoclasse di una sottoclasse -> si
tipoligie di visibilità -> pubblico privato protetto
membri -> pubblici possono essere visibili anche se non fai parte della classe,
privati visibili solo
membro protetto -> può essere visibile dalle sotto classi e da dalla classe
corrente
bynding dinamico -> chiamata del metedo overaidato
vettore -> zona di memoria
perchè si dice pseudocasuale e non casuale -> per creare un numero "casuale"
dobbiamo utilizzare un dato di partenza da cui verranno fatti dei calcoli
matematici per dare il numero pseudo casuale, il dato di partenza è il numero di
millisencondi dal momento dell'accensione della macchina
fondoscala -> il fondoscala è la dimensione massima che la barra dell'istogramma
può avere
//aerogramma -> vero nome del diagramma a torta

differenza tra le due collezioni -> Array e ArrayList, la differenza è la

dimensione, la dimensione in un array è statica mentre in una lista è dinamica
enum -> redifinizione di un intero tramite delle costanti
differenza tra linguaggio compilato e interpretato -> spiegami i passaggi della
compilazione
parola chiave super -> usato per accedere ai metodi della superclasse
.this -> maniglia dell'istanza corrente
i primitivi vengono passatti per copia, le istanze vengono passati tramite maniglia
quindi vengono modificati
path -> percorso delle cartelle per arrivare all'eseguibile
insieme di cartelle in cui cercare l'eseguibile

------------------------ 30/01/24 ------------------------------

due tipi di eredità -> extends e implements

tre tipi di visibilita -> privato, pubblico, protetto, package
comparatore -> serve per creare una relazione d'ordine, confronta due oggetti
omogenei
a quali membri posso accedere ai metodo privati di una sottoclasse -> non sono
accessibili
deserializzatore -> trasforma una stringa in un oggetto (costruttore tramite linea
di comando)
serializzazione -> trasforma un'oggeto in stringa (toString)
shadowing -> una variabile locale ha priorità maggiore su la variabile globare
serializzare -> metodo che trasforma un'oggetto in una stringa
jdk -> set di strumenti forniti da oracle per programmare in java
interfaccia -> classe con solo metodi non implementati
uml di una interfaccia INTERFACCIA < - - - SOTTOCLASSE
si può istanziare un'interfaccia -> no, perchè è astratta
cosa si utilizza per leggere un file -> la buff reader
binding dinamico -> in fase di runtime richiama un metodo overridato
promozione di una variabile -> passaggio di variabile, passa da locale a globale
con che classe scrivi su un file -> pinwriter
pinwriter e buffreader che classe fanno parte -> IO
eccezione -> errore che si solleva in fase di runtime

------------------------- 06/02/24 ------------------------

------------------------- 13/02/24 ------------------------

------------------------- 20/02/24 ------------------------

variabile statica -> variabile comune a tutte le istanze, non esiste questo
concetto in java perhè esistono i metodi statici, che sono comuni a tutte le
istanze.
deserializzare -> è un metodo che trasforma una stringa in un oggetto.
serializzatore -> è un metodo che trasforma un oggetto in una stringa.

parsificare -> trasformare il tipo di un attributo tramite dei algoritmi.

(castare è )
libreria per scrivere su file -> libreria IO, più precisamente la PrintWriter.

interfaccia -> una classe astratta che ha solo la firma dei metodi.

è possibile istanziare un'interfaccia -> solo se sei chuck norris

fino a quante classi posso estendere -> 1

file csv -> file di interscambio dati separati da un punto e virgola o solo
virgola.

come possiamo confrontare due stringhe -> tramite un metodo della classe Compare.

composizione e aggregazione -> composizione classe composta ad un'altra, quindi è

necessario che c'è ne sia almeno una, mentre nell'aggregazione no.

può un vettore contenere oggetti -> si, ma anche dati omogenei.

cosa puoi mettere in un arraylist -> solo oggetti, anche di diverso tipo ma devi
avere un'arraylist di tipo object

quantificatore per indicare la molteplicita delle aggregazioni ->

? 0..1 + 1..n * 0..n

quali tipi di costruttori -> costruttori default, per parametri e il costruttore

tramite stringa contenente un oggetto (chiamato deserializzatore)

garbage collector -> componente della runtime che serve a deistanziare gli oggetti
senza riferimento.

quando fallisce -> riferimento circolare.

------------------------- 27/02/24 ------------------------

------------------------- 05/03/24 ------------------------

------------------------- 12/03/24 ------------------------

------------------------- 19/03/24 ------------------------

------------------------- 26/03/24 ------------------------

------------------------- 02/04/24 ------------------------