Programmazione Java: StringBuilder, Javadoc, Metodi statici, Polimorfismo - Prof. La Casci, Appunti di Programmazione Java

Scarica Programmazione Java: StringBuilder, Javadoc, Metodi statici, Polimorfismo - Prof. La Casci e più Appunti in PDF di Programmazione Java solo su Docsity!

Appunti di Programmazione (9 CFU)

Ingegneria dell’Innovazione per le Imprese

Digitali

Sottile Claudio

Prof. Marco La Cascia

I

• Capitolo 1 - Introduzione Indice
  • Argomenti
  • Introduzione a Java........................................................................................................................................
  • Introduzione ai paradigmi di programmazione
  • Storia della OOP.............................................................................................................................................
    • C++
  • Storia di Java
    • Obiettivo: WORA – Write Once Run Anywhere
  • Caratteristiche di Java
    • Java Virtual Machine
  • JVM, JRE o JDK?
    • Struttura del JDK
  • Scrittura, Compilazione ed esecuzione
  • Primi programmi............................................................................................................................................
    • Hello World!
    • Programma – Moltiplica
• Capitolo 2 - Componenti di un programma Java
  • Outline
  • Classi e oggetti
  • Istanza degli oggetti.......................................................................................................................................
  • Attributi
  • Metodi
    • Metodi o funzioni?
    • Dichiarazione di un metodo
    • Invocazione di un metodo
  • Variabili
    • Dichiarazione di una variabile
  • Variabili d’istanza (o attributi)
    • Variabili locali
    • Parametri formali
  • Metodi costruttori
    • Costruttore di default
  • Package
    • Altre componenti importanti
• Capitolo 3 – Identificatori, Tipi di Dati e Array
  • Stile di codifica
    • Keywords di Java II
    • Standard e convenzioni per i nomi
  • Tipi di dati primitivi
    • Tipi di dati interi.......................................................................................................................................
    • Promozioni di tipo
    • Promozioni automatiche nelle espressioni aritmetiche
    • Casting esplicito
    • Troncamento in caso di overflow
  • Tipi di dati in virgola mobile
    • Letterali in virgola mobile
  • Classi wrapper
    • Underscore in letterali numerici..............................................................................................................
  • Tipo di dato logico - booleano
  • Tipo di dato primitivo letterale
  • Tipi di dati non primitivi: Reference
  • Passaggio di parametri per valori
  • Inizializzazione degli Attributi (Variabili d’istanza)
  • Introduzione alla Libreria Standard
    • Il comando import
  • Classe String.................................................................................................................................................
    • Classe StringBuilder
  • Javadoc
  • Array
    • Array multidimensionali (Matrici)
    • Riepilogo
• Capitolo 4 – Operatori e strutture di controllo
  • Outline
  • Operatori
    • Precedenza degli operatori
    • Operatori di base
    • Operatori composti
    • Operatori di pre/post incremento/decremento
    • Operatori Bitwise.....................................................................................................................................
    • Operatori relazionali
    • Operatori logici
    • Operatore ternario
  • Confronto fra oggetti
  • Concatenazione di String
  • Gestione del flusso di esecuzione III
  • Costrutti semplici.........................................................................................................................................
    • if e if else..................................................................................................................................................
    • while
  • Costrutti avanzati
    • for
    • do-while
    • for migliorato
    • switch.......................................................................................................................................................
    • break, continue e label
  • Riepilogo
• Capitolo 5 – Incapsulamento e Visibilità
  • Reference this
  • Uso di this con variabili................................................................................................................................
  • Uso di this con metodi
  • Uso dell’incapsulamento
  • Modificatori di accesso
  • Modificatore static
    • Metodi statici...........................................................................................................................................
    • Variabili statiche (di classe)
    • Quando usare static.................................................................................................................................
    • Inizializzatori statici ed inizializzatori d’istanza
  • import statici
  • Design Pattern Singleton
  • Riepilogo
• Capitolo 6 – Ereditarietà
  • Outline
  • Ereditarietà, parola chiave extends
    • Notazione UML
  • Modificatore final
  • Classe Object
  • Ereditarietà ed incapsulamento
  • Uso dell’ereditarietà
  • Ereditarietà e costruttori
  • Parola chiave super
    • Chiamare metodi con super
  • Riepilogo
• Capitolo 7 – Interfacce.....................................................................................................................................
  • Outline IV
  • Generalizzazione e specializzazione
  • Modificatore abstract
    • Metodi abstract
    • Classi astratte
  • Ereditarietà multipla....................................................................................................................................
  • Interfacce
    • Differenze tra interfacce e classi astratte................................................................................................
  • Ereditarietà multipla e interfacce................................................................................................................
  • Metodi statici...............................................................................................................................................
  • Metodi di default (Java 8)
    • Diamond Problem
  • Ereditarietà e inizializzatori
  • Riepilogo
• Capitolo 8 – Polimorfismo
  • Outline
  • Polimorfismo
  • Polimorfismo per metodi
    • Overload
    • Varargs
    • Override
  • Polimorfismo per dati
    • Parametri polimorfi
    • Collezioni eterogenee
    • Casting di oggetti
    • Invocazione virtuale dei metodi
    • Esempio d’utilizzo del polimorfismo
    • Polimorfismo e interfacce
  • Riepilogo
• Capitolo 9 – Eccezioni e asserzioni
  • Outline
  • Eccezioni, errori e asserzioni
  • Gerarchie e categorizzazioni........................................................................................................................
  • Meccanismo per la gestione delle eccezioni
  • Try with resources
  • Eccezioni personalizzate
    • Precisazione sull’override – throws e override
    • Warnings
  • Asserzioni..................................................................................................................................................... V
    • Quando usare le asserzioni......................................................................................................................
  • Riepilogo
• Capitolo 11 – Generics.....................................................................................................................................
  • Outline
  • Tipi parametro
    • Generics e collection
    • Uso di tipi primitivi
    • Interfaccia Iterartor
    • Interfaccia Map
  • Deduzione automatica del tipo
  • Ereditarietà dei Generics e Type erasure
  • Wildcards
    • Parametri e wildcard bounded
  • Creare propri tipi generici
    • Metodi generici
    • Parametri tipo bounded
    • Parametri Covarianti................................................................................................................................
  • Riepilogo
• Capitolo 12 – Libreria Base
  • Outline
  • Classe String
  • Classe Object
  • Classe Math
  • Classi wrapper
  • Autoboxing-Autounboxing
    • Pooling
    • Costrutti del linguaggio ed operatori relazionali
  • Interfacce Comparable
    • Ordinamento
  • Interfaccia Comparator
  • Riepilogo
• Capitolo 17 – Collections
  • Outline
  • Java Collections Framework
  • Interfaccia Collection
    • Iterare sulle collezioni............................................................................................................................
  • Interfaccia List
  • Implementazioni di List VI
• Interfacce Set e SortedSet
  • Implementazioni di Set e SortedSet
• Interfacce Queue e Deque
  • Implementazioni di Queue e Deque
• Interfacce Map e SortedMap
  • Implementazioni di Map e SortedMap
• Metodi di utilità
• Scelta dell’implementazione
• Riepilogo

Capitolo 1 - Introduzione Codice Teams: wztkv0u Il corso tratta in maniera approfondita la programmazione ad oggetti in Java. Verranno trattati sia gli aspetti relativi alla programmazione ad oggetti in generale che aspetti peculiari del linguaggio Java quali l’organizzazione del codice in package, la documentazione del codice e la libreria standard. Verranno infine trattate le strutture dati di uso più frequente inquadrandole nel contesto della libreria Java.

Argomenti

• Componenti fondamentali di un programma java
  • Basi della programmazione Java, metodi, variabili, costruttori, package.
  • Identificatori, tipi di dati, array
  • Operatori e gestione del flusso di esecuzione
• Programmazione a oggetti
  • Incapsulamento
  • Ereditarietà
  • Polimorfismo
• Eccezioni e asserzioni (gestione di situazioni anomale)
• Tipi generici, enumerazioni e tipi innestati
• Collezioni
  • Collection, List, Queue e Deque, Map e SortedMap
  • Algoritmi di utilità
• Libreria di Java
  • String, Object, System, Runtime e Math
  • Package java.util

Introduzione a Java

Introduzione ai paradigmi di programmazione

Un paradigma di programmazione è un modello concettuale e metodologico, offerto in termini concreti da un linguaggio di programmazione, al quale fa riferimento il programmatore per la progettazione e scrittura di un programma informatico. Esempi: Procedurale, a oggetti, Funzionale, Logico… Il paradigma procedurale è l’unità principale di programmazione è la procedura (o funzione ) che ha lo scopo di manipolare i dati del programma. È un paradigma di programmazione imperativo , e ciò consente di costruire un programma indicando dei comandi (assegna, chiama una procedura, esegui un loop) che esplicitano quali azioni si devono eseguire, e in quale ordine, in maniera assolutamente deterministica. È uno stile di programmazione orientato al “come fare e al come risolvere” piuttosto che al “cosa si desidera ottenere o cosa risolvere”. Esempi di linguaggi: C, Pascal, FORTRAN, COBOL. Nel paradigma a oggetti invece, l’unità principale di programmazione è l’ oggetto (nei sistemi basati sui prototipi) oppure la classe (nei sistemi basati sulle classi). L’oggetto è l’ astrazione concettuale di oggetti reali del mondo fisico che si vogliono modellare.

• Utilizziamo tali oggetti senza sapere nulla della complessità con cui sono costruiti e comunichiamo con essi attraverso l’invio di messaggi e mediante delle interfacce.
• Sono dotati di attributi che possono essere letti e, in alcuni casi, modificati. Gli oggetti reali vengono presi come modello per la costruzione di sistemi software a oggetti, dove l’oggetto (o la classe) avrà dei metodi per l’invio di messaggi e proprietà che rappresenteranno gli attributi da manipolare.

L’estensione del linguaggio C, realizzata da Bjarne Stroustrup, cota con il nome di C++ ha effettivamente rivoluzionato il mondo della programmazione. Fu scelto come linguaggio standard tra tanti linguaggi objected oriented dalle grandi corporation (Microsoft, Borland etc.), che iniziarono a produrre a loro volta tool di sviluppo per la programmazione C++. Un qualsiasi programma scritto in C deve poter essere compilato da un compilatore C++. Ciò, anche se ha favorito la migrazione in massa dei programmatori C verso il C++, si è rivelato anche uno dei limiti principali di quest’ultimo.

Storia di Java

Java propone uno stile di programmazione che in un certo senso obbliga a programmare correttamente a oggetti. Rispetto a C++, inoltre sono stati eliminati tutti gli strumenti ambigui e pericolosi. Se il C++ ha il merito di aver fatti conoscere al grande pubblico la programmazione ad oggetti, Java ha il merito di averla fatta capire. Java è un linguaggio di programmazione le cui origini risalgono al 1991, presso Sun Microsystems dove un team di programmatori (James Gosling, Patrick Naughton, Chris Warth, Ed Frank e Mike Sheridan) lavorò al suo sviluppo. Inizialmente chiamato OAK, fu sviluppato in seno a un progetto chiamato Green Project, e il progetto era quello di dotare svariati dispositivi elettronici di consumo di un meccanismo tramite il quale fosse possibile far eseguire, in modo indipendente dalla loro differente architettura, i programmi scritti per essi.

Obiettivo: WORA – Write Once Run Anywhere

Il meccanismo si sarebbe dovuto concretizzare nella scrittura di un componente software, denominato macchina virtuale, in grado di fare girare il codice intermedio, denominato bytecode, generato da un compilatore del linguaggio Java. Nel maggio del 1995 fu completato lo sviluppo di OAK, con l’annuncio alla conferenza Sun World ’95. Con l’occasione, visto che il nome OAK apparteneva già a un altro linguaggio di programmazione, si decise di cambiare il nome del linguaggio di Sun in Java. Nel 1996, alla prima JavaOne Developer Conference, venne rilasciata la versione 1.0 del JDK (Java Development Kit), e il successo di Java aumentò notevolmente con l’esplosione di Internet e del Web. All’inizio erano molto usate le applet, oggi ormai abbandonate, che sono dei programmi per gestire nel browser web contenuti dinamici e allo stesso tempo indipendenti dal sistema operativo e dal browser sottostante. Attorno al linguaggio furono create molteplici tecnologie, per esempio quelle per l’accesso indipendente ai database (JDBC), per lo sviluppo lato server del web (Servlet/JSP/JSF),… Oggi la tecnologia Java è la più utilizzata su applicazioni enterprise, e in tutto il mondo esistono miliardi di congegni elettronici che utilizzano tecnologia Java: cellulari, smartphone, decoder, smart card, robot.

Caratteristiche di Java

• Sintassi È piuttosto semplice e simile a quella del C e del C++;
• Gratuito Per scrivere applicazioni commerciali non bisogna pagare licenze a nessuno;
• Robustezza Questa è soprattutto una conseguenza di una gestione delle eccezioni chiara e funzionale, e di un meccanismo automatico della gestione della memoria (Garbage Collection) che esonera il programmatore dall’obbligo di dover deallocare memoria quando ce n’è bisogno. Il compilatore Java è molto “severo”, infatti il programmatore è costretto a risolvere tutte le situazioni “poco chiare”, garantendo al programma maggiori chance di corretto funzionamento. Meglio ottenere un errore in compilazione che in esecuzione.
• Libreria e standardizzazione

Java possiede un’enorme libreria di classi standard, ottimamente documentate. Permette anche ai neofiti di creare applicazioni complesse in breve tempo (interfacce grafiche, collegamenti a database, connessioni di rete). Grazie alle specifiche di Oracle, non esisteranno per lo sviluppatore problemi di standardizzazione come compilatori che compilano in modo differente.

• Indipendenza dall’architettura Grazie al concetto di macchina virtuale, ogni applicazione, una volta compilata, potrà essere eseguita su di una qualsiasi piattaforma.
• Java Virtual Machine Ciò che rende di fatto possibile l’indipendenza dalla piattaforma, è la Java Virtual Machine (JVM), un software che svolge un ruolo da interprete (ma non solo) per le applicazioni Java.

Java Virtual Machine

Il compilatore produce file che contiene la traduzione del nostro listato in un linguaggio molto vicino al linguaggio macchina detto “ bytecode ”. Una volta ottenuto questo file la JVM interpreterà il bytecode ed il nostro programma andrà finalmente in esecuzione. Se una piattaforma qualsiasi possiede una JVM, ciò sarà sufficiente per renderla esecutrice di bytecode. È il caso dell’OS Android, dove le applicazioni sono scritte in Java. “Macchina Virtuale” perché questo software è stato implementato per simulare un hardware. Il linguaggio macchina sta ad un computer come il bytecode sta ad una JVM. La JVM garantisce a Java tanti altri vantaggi. Per esempio, di essere un linguaggio multi-threaded (caratteristica di solito dei sistemi operativi). Inoltre garantisce dei meccanismi di sicurezza, la supervisione del codice da parte del Garbage Collector, validi aiuti per gestire il codice al runtime e tanto altro.

• Orientato agli oggetti Java ci fornisce infatti alcuni strumento che praticamente ci obbligano a programmare ad oggetti. I paradigmi fondamentali della programmazione ad oggetti (ereditarietà, incapsulamento, polimorfismo) sono più facilmente apprezzabili e comprensibili.
• Facilità di sviluppo Java ha delle caratteristiche che aiutano gli sviluppatori. Per esempio non esiste l’aritmetica dei puntatori e la memoria è gestita automaticamente con la Gabrage Collection. - Si possono ottenere risultati insperati in un tempo relativamente breve; - Una volta Java era considerato un linguaggio semplice. In realtà è un linguaggio molto complesso considerandone la potenza e tenendo presente che ci obbliga ad imparare la programmazione ad oggetti.
• Aperto Utilizzare Java non significa muoversi in un ambiente chiuso. Dalla scelta del tool di sviluppo all’interazione con altri linguaggi, librerie esterne e tecnologie (SQL, XML, framework open source ecc.).

JVM, JRE o JDK?

• La Java Virtual Machine ( JVM ) è la macchina virtuale: il software che simula un hardware capace di interpretare ed eseguire il bytecode contenuto in un file Java compilato
• Il Java Runtime Environment ( JRE , l’ambiente di esecuzione di Java) consiste in un software che mette a disposizione l’ambiente per utilizzare la JVM (e infatti la contiene). Per potere eseguire codice Java bisogna scaricare il JRE.
• Il Java Development Kit ( JDK ) è il software minimo che serve per sviluppare in Java. Contiene il JRE (e quindi la JVM) e una suite di strumenti per sviluppare

Struttura del JDK

All’interno della directory del JDK (che è in posizione dipendente dal sistema) sono presenti diverse sottodirectory:

• bin Contiene tutti i file eseguibili del JDK, ovvero javac, java, jar ecc.

System. out. print ( "Inserisci il secondo numero: " ); int input2 = keyboardScanner. nextInt (); System. out. print ( "Risultato: " + ( input1 ***** input2 )); } } Analisi del programma Il programma legge due valori in input da tastiera per poi stampare il prodotto tra questi.

Capitolo 2 - Componenti di un programma Java

Outline

• Classi
• Oggetti
• Attributi (dati membro)
• Metodi (funzioni membro)
• Variabili
• Costruttori
• Package
• Altri componenti fondamentali

Classi e oggetti

Una classe è un’ astrazione indicante un insieme di oggetti che condividono le stesse caratteristiche e le stesse funzionalità. Un oggetto è un’ istanza (ovvero una creazione fisica) di una classe. Nel contesto della programmazione ad oggetti, una classe dovrebbe quindi limitarsi a definire che struttura avranno gli oggetti che da essa saranno inizializzati. In senso molto lato, una classe può essere assimilata ad una struct di C, e aggiungere una classe è come creare un nuovo tipo di dato avente attributi e metodi.

• Una volta istanziati gli oggetti di una classe, devo vedere quali sono le sue caratteristiche.
• Da una classe posso istanziare uno o più oggetti.
• Dopo aver scritto le classi, nel main vengono istanziati gli oggetti con i quali faremo operazioni, ed un programma è visto come un insieme di oggetti che interagiscono tra loro. Esempio: public class Punto { public int x ; public int y ; } Dove x e y non sono delle variabili, ma delle proprietà che avrà ogni oggetto della classe Punto. Possiamo già compilare la classe ma non eseguirla, poiché quasi sempre una classe non fa nulla se non istanziamo oggetti. Il ruolo della classe è quello di definire un concetto, un modello, un’idea, e ci dà indicazioni sulla struttura del programma. Nota Bene: Solitamente le classi NON dovrebbero avere un main. Esempio: public class Prova { public static void main ( String args []){ Punto punto1 ; //oggetto dichiarato e non ancora istanziato punto1 = new Punto (); //oggetto istanziato punto1. x = 2 ; punto1. y = 6 ; Punto punto2 = new Punto (); //oggetto dichiarato e istanziato punto2. x = 0 ; punto2. y = 1 ; System. out. println ( punto1. x ); System. out. println ( punto1. y ); System. out. println ( punto2. x ); System. out. println ( punto2. y );

Metodi o funzioni?

Nella programmazione procedurale tutti i programmi erano formati da un programma chiamante e da un certo numero di funzioni. Queste avevano di fatto il compito di risolvere determinati “sotto-problemi” generati da un’analisi di tipo top-down, allo scopo di risolvere il problema generale Nella programmazione orientata ad oggetti invece, i “sotto-problemi” saranno invece risolti tramite l’astrazione di classi ed oggetti, che a loro volta definiranno dei metodi. Nota Bene: Ovviamente un metodo è una funzione, ma è scorretto considerare metodo e funzione la stessa cosa. Nota Bene: Ai valori non inizializzati nelle classi viene assegnato automaticamente il valore NULL.

Dichiarazione di un metodo

[modificatori] tipo_di_ritorno nome_del_metodo ([parametri]){corpo_del_metodo} Esempio: public class Calcolatrice { public int somma ( int a , int b ){ return( a + b ); } }

Invocazione di un metodo

Classe eseguibile (ovvero contenente il metodo main () ), che istanzia un oggetto Calcolatrice e chiama il metodo somma () : public class Uno { public static void main ( String args []){ Calcolatrice casio = new Calcolatrice (); int risultato = casio. somma ( 5 , 6 ): } } È possibile creare dei metodi senza parametri (nessun argomento tra le parentesi), senza valore di ritorno (metodo di tipo void) o con un numero variabile di parametri.

Variabili

Le variabili sono porzioni di memoria in cui è immagazzinato un certo tipo di dato.

Dichiarazione di una variabile

[modificatori] tipo_di_dato nome_della_variabile [= inizializzazione]; Esempio: public class Rettangolo { public int altezza ; public int larghezza ; public final int NUMERO_LATI = 4 ; } In questo caso le variabili vanno viste come caratteristiche degli oggetti.

Variabili d’istanza (o attributi)

Gli attributi sono quelle variabili dichiarate dentro una classe ma fuori da un metodo , e il ciclo di vita degli attributi coincide con quello dell’oggetto a cui appartengono. Sono inizializzate automaticamente. Nota Bene: in Java non è possibile definire variabili fuori dalle classi.

Variabili locali

Sono le variabili di stack, variabili automatiche o variabili temporanee. Non sono inizializzate automaticamente ed è buona prassi inizializzarle a valori di default, e il loro ciclo di vita va dalla definizione della variabile alla fine del blocco in cui è definita. Esempio: public int somma ( int x , int y ){ int z = x + y ; return z ; } z verrà eliminata non appena finisce l’esecuzione di somma ().

Parametri formali

I parametri formali sono i parametri o argomenti del metodo. Esempio: public int somma ( int x , int y ){ return ( x + y ); } Sono inizializzati al momento della chiamata: int risultato = oggetto1. somma ( 5 , 6 ); i parametri si possono considerare variabili locali dei metodi.

Metodi costruttori

I metodi costruttori sono dei metodi particolari, aventi le seguenti caratteristiche:

• Devono avere lo stesso nome di ritorno;
• Non hanno tipo di ritorno;
• Possono avere dei parametri;
• Ce ne possono essere diversi per la stessa classe;
• Sono chiamati automaticamente in fase di istanziazione ( new ). Esempio: Nella classe Punto potrei avere il seguente costruttore, che verrà eseguito automaticamente quando istanzio un oggetto Punto, import java. util. Date ; public class Punto { public int x ; public int y ; public Punto (){

public class Punto {

... Secondo lo stesso ragionamento di prima, il file compilato dovrà risiedere all’interno della cartella geometria , che a sua volta sarà all’interno della cartella matematica , a sua volta contenuta in una cartella studio_. Per poter utilizzare il metodo Punto, questo dovrà essere importato nel main_ () , e ciò è possibile farlo inserendo all’inizio della classe eseguibile la seguente riga di codice: package studio. matematica. geometria. test ; import studio. matematica. geometria. Punto ; public class TestPunto { public static void main ( String [] args ){ Punto p = new Punto (); ... } } Per compilare un file che va inserito nel package bisogna eseguire nel terminale la riga: javac - d. nomeClasse.java Per eseguire il codice: java nomePackage.nomeClasse Anche l'accesso agli elementi pubblici che fanno parte di un package diverso da quello in cui una classe si trova deve avvenire in modo diverso che non semplicemente facendo riferimento al nome della classe.

Altre componenti importanti

Altre componenti importanti del linguaggio Java sono:

• Interfacce
• Enumerazioni
• Annotazioni
• Moduli (da Java 9)
• Inizializzatori
• Classi innestate
• Espressioni lambda (da Java 8)

Capitolo 3 – Identificatori, Tipi di Dati e Array Outline

• Stile di codifica
• Tipi di dati primitivi
• Tipi di dati non primitivi: reference
• Introduzione alla libreria standard
• Array

Stile di codifica

Il linguaggio Java:

• È a schema libero : o Ritorni a capo ignorati dal compilatore; o Stili di indentazione, è possibile indentare il codice come meglio si preferisce poiché questo non inciderà minimamente sulla compilazione (Al contrario di Python);
• È Case sensitive ;
• Supporta i commenti : o Singola riga // o Multiriga /…/ o Javadoc /*…/
• Supporta gli identificatori (nomi) dei metodi, delle classi, degli oggetti, delle variabili e delle costanti: o Un identificatore non può coincidere con una parola chiave ( keyword ) di Java; o Il primo carattere non può essere un numero, quindi può essere A-Z, a-z, _, $. Il secondo ed i successivi possono essere A-Z, a-z, _, $, 0-9.

Keywords di Java

Standard e convenzioni per i nomi

Se definiamo gli identificatori (nomi) rispettando le due regole appena descritte, non otterremo errori in compilazione. Tuttavia esistono direttive fornite direttamente da Oracle per raggiungere uno standard anche nello stile d’implementazione.

1. Gli identificatori devono essere nomi significativi.
2. Convenzioni per le classi:
   • Devono essere al singolare;
     • Deve iniziare con la lettera maiuscola;
     • Fare iniziare ogni parola con una maiuscola ( Es. FiguraGeometrica ).
3. Variabili e metodi:
   • Devono iniziare con la lettera minuscola;
   • Le variabili devono iniziare con dei sostantivi ( Es. numeroLati );
   • I metodi devono iniziare con dei verbi ( Es. stampaPerimetro ).