Classi esame Fondamenti programmazione

COSE DA SAPERE:

Java è un linguaggio di programmazione object oriented, ovvero un linguaggio di

programmazione ad oggetti.

L’esecuzione di qualunque applicazione Java stand-alone coincide con l’esecuzione del

metodo main di una classe.

Ogni classe contiene la dichiarazione di metodi . Ogni metodo contiene una sequenza di

istruzioni . Un metodo contiene una sequenza di istruzioni che determina come portare a

termine un compito specifico . Un metodo viene invocato specificando i suoi argomenti Ogni

applicazione Java contiene una classe con un metodo main.

Produzione del codice sorgente (file.java).

Un editor è un programma che permette di inserire e modificare del testo . Java è “Case

Sensitive”. Il compilatore Java traduce il codice sorgente in file di tipo class .I file di tipo class

contengono le istruzioni per la Java Virtual Machine

Compile-time error: Una violazione delle regole del linguaggio di programmazione

identificata dal compilatore Esempio: System.out.println("Hello, World!);

Run-time error: Un errore che si verifica durante l'esecuzione di un programma che ne

provoca un comportamento diverso dal previsto Esempio: System.out.println("Hello,

World!"); System.out.println(1/0); Logic error: il codice produce un risultato errato

Un'istanza di una classe è un oggetto concreto creato a partire da una classe, che

rappresenta un'entità specifica con le sue proprietà e comportamenti definiti dalla classe.

Gli attributi (o campi) sono variabili definite all'interno di una classe e rappresentano le

caratteristiche o le proprietà di un oggetto. Ogni istanza di una classe (oggetto) ha i propri

valori per questi attributi.

I parametri sono variabili utilizzate nei metodi o nei costruttori per accettare valori in

ingresso. Servono per passare informazioni ai metodi o per inizializzare gli oggetti.

Un nome è valido se inizia per un carattere alfabetico o il carattere underscore _ o il

carattere dollaro $ , contiene solo caratteri alfabetici, numerici, underscore e dollaro,

è lungo meno di 65535 caratteri

Ogni classe è contenuta in un file con estensione .java e nome esattamente uguale a quello

della classe (in modo case sensitive). Ogni file quindi contiene esattamente una classe .

Anche se è possibile ammassare nello stesso file le definizioni di più classi (purché non

precedute dalla parola public) questo è sconsigliato.

Top-down: Si parte dal sistema generale e lo si divide progressivamente in sottosistemi più

piccoli. Ad esempio, si inizia progettando l'intero flusso di un'applicazione prima di

implementare dettagli come classi o metodi specifici.

Bottom-up: Si inizia progettando componenti o moduli di base (ad esempio classi o metodi)

e li si combina per formare sistemi più grandi e complessi.(Java)

La programmazione ad oggetti consente di manipolare gruppi di variabili correlate e non

singole variabili. Le variabili vengono aggregate in oggetti. La programmazione ad oggetti

si basa sull’incapsulazione delle variabili all’interno degli oggetti e sulla creazione di codice

che descrive il comportamento interno ed esterno di tali oggetti.

L’incapsulamento è la proprietà per cui la struttura interna dell’oggetto è nascosta agli altri

oggetti. La comunicazione tra oggetti avviene tramite l’invio di messaggi. L’implementazione

dei messaggi avviene tramite le chiamate dei metodi degli oggetti. L’incapsulamento fa sì

che le operazioni dell'oggetto non possano essere in nessun modo influenzate da altri

oggetti.

Un oggetto è rappresentato da variabili e da comportamenti assunti, ed ha un tipo(classe).

Una classe in Java è un modello che definisce le proprietà (attributi) e i comportamenti

(metodi) degli oggetti che verranno creati da essa (rappresenta l’astrazione di oggetti aventi

le stesse caratteristiche nel dominio del problema da risolvere).

I dati membro di un oggetto sono gli attributi (o campi) definiti all'interno della classe da

cui l'oggetto è stato creato. Essi rappresentano lo stato o le proprietà specifiche di

quell'oggetto.Ogni oggetto ha la propria copia dei dati membro, il che significa che gli

attributi possono assumere valori diversi per oggetti diversi della stessa classe.

L’ereditarietà è il meccanismo mediante il quale una classe acquisisce tutte le

caratteristiche di un'altra classe definita in precedenza La classe che eredita le

caratteristiche è chiamata sottoclasse La classe che fornisce le proprie caratteristiche

viene chiamata superclasse Una sottoclasse contiene tutto ciò che si trova nella sua

superclasse.

Il polimorfismo è la capacità che hanno oggetti di classi diverse (ma correlate per il fatto di

derivare da una classe base comune) di rispondere in maniera diversa ad uno stesso

messaggio.

Un costruttore in Java è un metodo speciale di una classe che viene chiamato

automaticamente quando viene creata un'istanza di quella classe, ed è usato per

inizializzare gli attributi dell'oggetto.

I costruttori devono sottostare alle seguenti regole: devono avere lo stesso nome della

classe, non bisogna specificare il tipo di ritorno (neanche void) ;possono esistere più

costruttori, in “overload”, in una stessa classe. Java li distingue in base alla lista degli

argomenti

Directory: Una directory è una cartella nel file system che organizza i file in modo

strutturato, creando una gerarchia di contenitori.

Package in Java: Un package in Java è un insieme di classi e interfacce organizzate in una

struttura di directory, usato per gestire e raggruppare il codice in modo ordinato e per evitare

conflitti di nomi tra classi.

All’atto pratico un package è un insieme di file.class tipicamente archiviati in un file

compresso .zip o .jar • Ogni classe appartiene ad un package: la dichiarazione di

appartenenza può essere effettuata all’inizio del codice della classe usando la parola

riservata package seguita dal nome del package • Se non si dichiara esplicitamente il

package la classe viene assegnata ad un package “anonimo” che contiene, oltre ad essa,

tutte le classi senza package presenti nella stessa directory

UML è un linguaggio di progettazione che fornisce una serie di diagrammi per rappresentare

ogni tipo di modellazione

Il diagramma delle classi rappresenta le classi che compongono il sistema, cioè le

collezioni di oggetti, ciascuno con il proprio stato e comportamento (attributi ed operazioni)

Specifica, mediante associazioni, le relazioni fra le classi.

+----------------------+

| Persona | <-- Nome della classe

+----------------------+

| - nome: String | <-- Attributo privato

| - età: int | <-- Attributo privato

+----------------------+

| + getName(): String | <-- Metodo pubblico

| + setNome(nome: String): void | <-- Metodo pubblico

| + getEtà(): int | <-- Metodo pubblico

| + setEtà(età: int): void | <-- Metodo pubblico

| + saluta(): void | <-- Metodo pubblico

+----------------------+

Le convenzioni principali nei diagrammi delle classi UML sono:

+ -

1.​ Il simbolo indica visibilità pubblica e indica visibilità privata.

2.​ Le classi sono rappresentate come rettangoli divisi in tre sezioni: nome, attributi e

metodi.

this

L'uso di è particolarmente utile quando si fa riferimento a una variabile di istanza

e il nome di quella variabile è lo stesso di un parametro del metodo o di una variabile

this

locale. In questi casi, aiuta a distinguere chiaramente la variabile di istanza dalla

variabile locale o parametro.

Variabile: Contenitore che memorizza un valore (per tipi primitivi) o un riferimento a un

oggetto.

Oggetto: Istanza di una classe che rappresenta un'entità con uno stato (dati) e

comportamenti (metodi).

I livelli di accesso/visibilità sono 4, i modificatori sono 3 (uno è il default)

– public : dovunque

– protected : all'interno del package e delle classi derivate

– friendly : all'interno del package (default)

– private : all'interno della sola classe

La classe derivata può definire attributi che non erano presenti nella classe base .

Ogni oggetto istanza della classe derivata ha quindi la seguente dotazione di attributi:

– quelli presenti nella definizione della classe derivata

– quelli presenti per eredità dalla classe base (che a sua volta poteva averli ereditati …)

L'overloading è il processo in cui due o più metodi all'interno della stessa classe

condividono lo stesso nome, ma si differenziano per il numero o il tipo dei parametri.

1.​ Avviene nella stessa classe (o in una classe genitore-figlia).

2.​ I metodi devono avere lo stesso nome ma una firma diversa (diverso numero o tipo

di parametri).

3.​ Non è influenzato dal tipo di ritorno del metodo

I metodi overloaded sono a tutti gli effetti metodi diversi (hanno argomenti diversi)

In pratica i metodi overloaded hanno in comune solo il nome.

L'overriding è il processo attraverso il quale una classe figlia fornisce una nuova

implementazione di un metodo ereditato da una classe genitore. Il metodo nella classe

figlia deve avere lo stesso nome, lo stesso numero e tipo di parametri, e la stessa firma

del metodo nella classe genitore.(In particolare è molto comune ridefinire il metodo toString),

@Override

Richiede l'uso della parola chiave

I metodi overridden sono ridefinizioni di un metodo già esistente: tra loro esiste la relazione

di mascheramento.

Più in generale l'overriding permette di ridefinire e specializzare metodi definiti in una

superclasse. super

In Java, la parola chiave viene utilizzata per richiamare un metodo della

superclasse che è stato sovrascritto (overridden) dalla classe figlia. Quando una classe

figlia ridefinisce un metodo che è già presente nella sua superclasse, è possibile utilizzare

super.metodo() per invocare il metodo originale della superclasse, bypassando

l'implementazione nella classe figlia.

super()

In Java, viene utilizzato anche per richiamare il costruttore della superclasse

all'interno di un costruttore della sottoclasse. Questo permette alla sottoclasse di inizializzare

la parte della superclasse correttamente prima di eseguire la propria inizializzazione. Se non

viene esplicitamente invocato un costruttore della superclasse, Java chiama

automaticamente il costruttore senza argomenti della superclasse.

Il polimorfismo permette di scrivere codice generico che si "adatta" automaticamente a

tutte le specializzazioni di una certa classe (anche quelle future), ed una proprietà

fondam