19/05/08 – prima lezione

OGGETTO

attributi
CLASSE metodi
PACKAGE
storia di Java

C’era una volta nel 1991, a Mountain View in California, un azienda di computer chiamata Sun
Microsystem che costituì un nuovo piccolo gruppo di ricerca e sviluppo con lo scopo di creare
una tecnologia sulla quale l’industria dell’elettronica ( televisori, altri piccoli dispositivi, ecc.)
poteva contare. Al team, fisicamente separato dalla società da cui era nato, gli fu assegnata
una missione: sviluppare un ambiente software platform-indipendent, semplice da utilizzare,
che doveva essere installato in questi piccoli e portabili “articoli elettronici”. L’obiettivo fu anche
proposto a James Gosling che si associò da subito al team.

Il Green Team
Al progetto a cui iniziarono a lavorare Gosling & Co., fu dato un nome: “Green Project”.
“Green” in quanto tutti i componenti avevano poca esperienza nello sviluppo di software nel
settore dell’elettronica di consumo. Inizialmente infatti svilupparono un software adatto alle
esigenze della mini-elettronica, ben lontano da rendere i personal computer facili da utilizzare.
I consumatori, che si aspettavano qualcosa di stabile ed a basso costo, non furono disposti ad
acquistare e ad imparare la nuova tecnologia, per niente stabile e con numerosi bug.

I primi sviluppi
Un altro ostacolo da superare fu l’indipendenza dalla piattaforma, per andare incontro ai
consumatori che non sapevano di che CPU disponevano e perché molto spesso anche i
produttori sostituivano la CPU con nuove versioni per abbassare i costi. Il Green Team partì
quindi dal presupposto di non conoscere la piattaforma (CPU e sistema operativo) sulla quale il
nuovo software doveva essere eseguito.
Con questi presupposti, il team di Gosling sviluppò un sistema derivante dalla estensione del
compilatore C++ che però ben presto non rispettò le aspettative. Fu a questo punto che
Gosling fece partire il Green Project, ovvero un progetto totalmente nuovo sulla base di
specifiche che aveva in mente. Nacque così, intorno alla metà del 1991, Oak, un linguaggio di
programmazione object oriented, platform-indipendent, robusto e sicuro.
Il nome Oak deriva dal fatto che Gosling nella definizione delle directory del nuovo linguaggio
si ispirò ad una quercia che vedeva attraverso la finestra del suo ufficio.

I primi frutti
Nell’agosto del 1992 il Green Team rilasciò “*7 (Star Seven)”, un dispositivo simile ad un PDA.
Chiamato come una sequenza di tasti ripetutamente utilizzata dal team, “*7” era basato su
quattro tecnologie sviluppate dal team:

- Il linguaggio Oak
- GreenOS, un sistema operativo
- Una interfaccia utente
- Il dispositivo stesso

Tutte e quattro le tecnologie furono sviluppate molto velocemente, in un anno e mezzo di

lavoro del team. Il risultato ottenuto fu presentato dal team al CEO di Sun del tempo, Scott
McNealy. Essi utilizzarono nella presentazione un personaggio dei cartoni animati (Duke), il
quale guidava l’utente attraverso questo mondo virtuale. Visti i risultati, Sun decise di mettere
sul mercato il prodotto, così mentre si miglioravano alcuni aspetti, parte dei membri del team
si dedicò allo studio delle strategie di mercato per la vendita del prodotto.

Primo tentativo – FirstPerson Inc.

“*7” fu visto come un prodotto vendibile ai produttori di elettronica che potevano mettere il
loro logo e venderlo al pubblico. Questo fu in effetti quello che fece, ad esempio, Dolby Labs
riscuotendo enorme successo per molti anni. Ben presto però il team decise di vendere
direttamente il prodotto, così il Green Team assunse una forma societaria, FirstPerson Inc.
Anziché, però, indirizzare tutti gli sforzi al mercato dell’elettronica di consumo, il team fu
distratto da un settore tecnologico: “television set-top box”, ovvero la rivoluzione della
televisione tradizionale, che consisteva nel rendere disponibile più di 500 stazioni televisive, la
possibilità di scegliere in qualunque momento qualunque tipo di programma, di poter
selezionare il film da vedere (video on-demand). Per realizzare tutto questo ogni televisore
doveva essere fornito di un “set-top box”, un dispositivo elettronico consistente in una unità di
controllo remoto.

Una falsa Partenza

FirstPerson insieme a Sun decisero di entrare in questo settore approfittando di una RFP
(Request For Proposal) da parte di Time-Warner, che aveva richiesto delle proposte nel settore
dell’innovazione televisiva. Il team cambiò così direzione passando dal mercato dell’elettronica
a quello della televisione on-demand. Malgrado le anticipazioni favorevoli, la proposta di
FirstPerson/Sun a Time-Warner fu scartata. Nonostante essi offrissero una tecnologia
superiore, fu scelta la proposta di Silicon Graphics.

Riacquistare fiducia
Nonostante quanto era accaduto, FirstPerson/Sun continuò la ricerca nel settore del mercato
“set-top box”, accordandosi con 3DO per la fornitura di un sistema operativo “set-top box”.
Dopo qualche mese la tecnologia fornita da FirstPerson non soddisfò le esigenze di 3DO e
l’accordo sfumò. Nel dicembre del 1993, Sun concluse che la direzione e la strategia intrapresa
da FirstPerson non aveva sbocchi sul mercato del “set-top box”. Nei primi mesi del 1994,
Gosling ed il suo team decisero che il mercato della televisione “set-top box” non era
perseguibile, almeno al livello che loro
pensavano. Così il team cambio
nuovamente direzione dirigendosi verso i
servizi on-line, i Cd-Rom ed i sistemi basati
sulle reti. Il nuovo piano fu presentato
ufficialmente a Sun che non lo considerò
abbastanza valido, tanto che alla fine
dell’anno FirstPerson fu definitivamente
chiusa e metà del team fu licenziato
mantenendo solo poche persone.

Si cambia rotta: puntare sul Web

Nel giugno del 1994, dopo il fallimento di
FirstPerson, Oak intraprese un’altra
direzione, fu sfruttato da Bill Joy (co-
fondatore di Sun) per progettare e
sviluppare LiveOak “un grande-piccolo
sistema operativo”. In pochi mesi il
progetto fu ridotto, indirizzandolo
esclusivamente ad Internet e nel Gennaio
del 1995 fu rinominato Java. Inoltre
nell’autunno dello stesso anno Van Hoff
implementò il compilatore Java utilizzando
Java, mentre quello esistente era stato
realizzato da Gosling in C++. In questo
periodo aumentava l’attenzione sul World
Wide Web, sebbene i browser erano alla
loro prima generazione (NCSA Mosaic 1.0).
Perché allora non tentare di sviluppare un
browser di seconda generazione utilizzando
questo linguaggio? In un week-end, uno dei
membri del team, Patrick Naughton
sviluppò un prototipo di browser di nuova
generazione basato su Java. Il team,
compreso Gosling, ancora una volta cambiò rotta, questa volta dirigendo i propri sforzi verso il
Web. In pochi mesi Naughton ed un suo collega Jonathan Payne completarono quello che loro
chiamarono “WebRunner”. Un browser basato su una tecnologia sconosciuta alla prima
generazione dei browser e scritto con il linguaggio Java. Nacque così quello che fu ribattezzato
HotJava v1.0.
Il giorno del successo
Il 23 Maggio 1995 Sun Microsystem introdusse formalmente Java e HotJava in occasione del
SunWorld ’95. Dopo anni di duro lavoro, sacrifici, problemi, delusioni e perseveranza la visione
del Green Team ebbe successo, un nuovo grande prodotto fu lanciato sul mercato. Con Java,
Sun dimostrò che era riuscita a realizzare il primo linguaggio di programmazione che era
“slegato” da ogni sistema operativo o microprocessore. Nel Gennaio del 1996 Sun fondò
JavaSoft, una unità dedicata allo sviluppo di prodotti basati sulla tecnologia Java,
all’aggiornamento del linguaggio e alla collaborazione con terze parti per creare applicazioni,
tool e servizi per migliorare le capacità del linguaggio. Nello stesso mese JavaSoft rilasciò il
Java Development Kit (JDK) 1.0, un collezione rudimentale di componenti per facilitare lo
sviluppo di applicazioni scritte in Java, tra cui: un compilatore, un applet viewer, un prototipo di
debugger, la Java Virtual Machine (JVM) necessaria per eseguire programmi basati su Java su
qualunque piattaforma e numerose librerie di classi per la grafica, l’audio, le animazioni ed il
networking. Da questo punto in poi JavaSoft, anche con le segnalazioni dei sempre più
numerosi programmatori Java, ha apportato periodicamente aggiornamenti e miglioramenti al
JDK sino ad arrivare alla versione 1.2. Il resto è storia dei giorni nostri…
progetto di esempio sul paradigma a oggetti

package lezione001;

public class Main {

public static void main(String[] args) {

// creo un nuovo oggetto di tipo "persone"

persone mario = new persone(1991,'M',"Mario","Rossi");

// chiamo il metodo "calcolaEta" dell’oggetto "mario" e scrivo il risultato a video

System.out.println("Mario ha " + mario.calcolaEta(2007) + " anni");

public class persone {

// attributi
public int annoDiNascita;
public String nome;
public String cognome;
public char sesso;

// costruttori
public persone(int annoDiNascita, char sesso, String nome, String cognome) {
this.annoDiNascita = annoDiNascita;
this.nome = nome;
this.cognome = cognome;
this.sesso = sesso;
}

// metodi
public int calcolaEta(int annoAttuale) {
return (annoAttuale - annoDiNascita);
}

esercizio

scrivere un metodo che rappresenti a video nome cognome ed età della persona; soluzione (il
metodo va aggiunto alla classe persone):

public void scriviEta(int annoAttuale) {

System.out.println(this.nome + " " + this.cognome
+ " ha " + this.calcolaEta(annoAttuale) + " anni");
}

e da main potremo chiamare

mario.scriviEta(2008);
progetto di esempio sull’ereditarietà

package lezione001;

public class studenti extends persone {

// attributi
public int matricola;
public int votoStoria;
public int votoItaliano;
public int votoGinnastica;

// costruttori
public studenti
(int annoDiNascita, char sesso, String nome, String cognome, int matricola) {
super(annoDiNascita,sesso,nome,cognome);
this.matricola = matricola;
}

// metodi
public String scriviMatricola (char separatore) {
return Integer.toString(matricola) + separatore + Integer.toString(annoDiNascita);
}

esercizio

overloadare il metodo scriviMatricola per poter scrivere la matricola con un separatore di

default (il carattere slash); soluzione

public String scriviMatricola () {

return scriviMatricola('/');
}

esercizio

creare un metodo in studenti che assegni i voti a un dato studente; soluzione

public void assegnaPagella(int votoStoria, int votoItaliano, int votoGinnastica) {

this.votoStoria=votoStoria;
this.votoItaliano=votoItaliano;
this.votoGinnastica=votoGinnastica;
}

esercizio

creare un metodo che calcoli la media dei voti di uno studente; soluzione:

public float calcolaMedia() {

return (float) (votoStoria + votoItaliano + votoGinnastica) / 3;
}

esercizio

creare un metodo che partendo dai voti di uno studente restituisca l’esito dell’anno scolastico
(se la media è inferiore a cinque, bocciato; fra cinque e sei promosso con debito; sopra il sei
promosso); soluzione:

public String esitoFinale() {

 if(this.calcolaMedia() < 5)
return "bocciato";
else if(this.calcolaMedia() >= 5 && this.calcolaMedia() < 6)
return "promosso con debito";
else
return "promosso";

}
i modificatori di accesso

I modificatori di accesso regolano essenzialmente l’accesso ad un componente Java:

public:

Può essere utilizzato sia relativamente ad un membro (attributo o metodo) di una classe, sia relativamente ad
una classe stessa. Abbiamo già abbondantemente visto l’utilizzo relativo ad un membro di una classe.
Sappiamo oramai bene, che un membro dichiarato pubblico, sarà accessibile da una qualsiasi classe situata in
qualsiasi package.

Una classe dichiarata pubblica, sarà anch’essa visibile da un qualsiasi package.

protected:

Questo modificatore definisce per un membro, il grado più accessibile dopo quello definito da public. Un
membro protetto, sarà infatti accessibile all’interno dello stesso package, ed in tutte le sottoclassi della classe in
cui è definito, anche se non appartenenti allo stesso package.

default:

Se non anteponiamo modificatori d’accesso ad un membro di una classe, esso sarà accessibile solo da classi
appartenenti al package dove è definito. Se dichiariamo una classe appartenente ad un package, senza
anteporre alla sua definizione il modificatore public, essa sarà visibile solo dalle classi appartenenti allo stesso
package. Possiamo considerare allora anche un incapsulamento di secondo livello.

private:

Questo modificatore restringe la visibilità di un membro di una classe alla classe stessa.

Il tutto è riassunto nella seguente tabella riguardante i modificatori di accesso e la relativa visibilità (solo per i
membri di una classe):

final:

Questo semplice modificatore ha un’importanza fondamentale. È applicabile sia a variabili, sia a metodi, sia a
classi. Potremmo tradurre il termine final proprio con "finale", nel senso di "non modificabile". Infatti una
variabile dichiarata final diviene una costante; un metodo dichiarato final non può essere riscritto in una
sottoclasse (non è possibile applicare l’override); una classe dichiarata final non può essere estesa.
static:

Questo modificatore rappresenta un fondamentale e potente comando di Java. Con static, la programmazione
ad oggetti, trova un punto di incontro con quella strutturata, ed il suo uso, deve essere quindi limitato a
situazioni in cui realizzi in una concreta utilità. Potremmo tradurre il termine static con "condiviso da tutte le
istanze della classe", oppure "della classe". Per quanto detto, un membro statico ha la caratteristica di poter
essere utilizzato mediante una particolare sintassi del tipo:

nomeClasse.nomeMembro

in luogo di:

nomeOggetto.nomeMembro

Anche senza istanziare la classe, l’utilizzo di un membro statico, provocherà il caricamento in memoria della
classe contenente il membro in questione, che quindi, condividerà il ciclo di vita con quello della classe.

abstract:

Il modificatore abstract può essere applicato a classi e metodi. Un metodo astratto, è un metodo che non
implementa un proprio blocco di codice e quindi il suo comportamento. In pratica, un metodo astratto, non ha il
blocco di codice, ma termina con un punto e virgola. Un esempio di metodo astratto potrebbe essere il
seguente:

public abstract void dipingiQuadro();

Ovviamente, questo metodo, non potrà essere chiamato, ma potrà essere soggetto a riscrittura (override) in
una sottoclasse. Inoltre, un metodo astratto, potrà essere definito solamente all’interno di una classe astratta.
In altre parole, una classe che contiene anche un solo metodo astratto, deve essere dichiarata astratta. Una
classe dichiarata astratta, non può essere istanziata. Quindi, il programmatore che ha intenzione di marcare
una classe con il modificatore abstract, deve essere consapevole a priori che da quella classe non saranno
istanziabili oggetti.

N.B.: il grosso vantaggio che offre l’implementazione di una classe astratta, è che "obbliga" le sue sottoclassi ad
implementare un comportamento. A livello architetturale, la progettazione di classi astratte è un strumento
fondamentale.
20/05/08 – seconda lezione
tipi di dati

Java ha due gruppi di tipi di dati, tipi di dati primitivi e riferimenti a oggetti.

Java tipi di dati primitivi

Tipo di dati Scopo Sommario Valore di default *
booleano Valore di verità vero o falso fales
char Carattere Caratteri Unicode \ u0000
byte Firmato integer 8 bit complemento a due (byte) 0
breve Firmato integer 16 bit complemento a due (a breve) 0
INT Firmato integer 32 bit complemento a due 0
lungo Firmato integer A 64 bit complemento a due 0L
float Numero reale A 32 bit IEEE 754 in virgola mobile 0.0f
doppio Numero reale A 64 bit IEEE 754 in virgola mobile 0.0d

Un modo per ricordare il Java primitiva tipi di dati è di utilizzare questo aiuto mnemonico:
Attenzione: Attenzione, Orsi Orsi Shouldn Se non ingerire ingerire Grande Grande Furry Furry
Cani Cani.

* Grado variabili vengono assegnati valori di default; variabili locali non vengono assegnati valori
di default.

Riferimenti a oggetti Java

Java riferimenti a oggetti sono variabili che detengono i riferimenti agli oggetti.

A differenza di Java primitiva tipi di dati che memorizzare dati effettivi, riferimenti a oggetti
memorizzare soltanto un riferimento ai dati effettivi oggetto.

Variabili e Tipi di dati

Home + Java + Guida Java + Variabili e Tipi di dati
Le Variabili sono dei nomi identificativi che permettono di memorizzare determinati valori definiti dai Tipi di dati, possono
anche diventare Oggetti istanziati da una classe precedentemente creata o presa dalle librerie, come nel caso dell'oggetto
String (occhio alla prima lettera maiuscola). E' obbligatorio in Java dichiarare la variabile a seconda del tipo: per esempio per
dichiarare una variabile locale numerica intera dobbiamo scrivere un istruzione con il nome della variabile preceduta dal tipo di
dato int:
int NomeVariabile;
E' anche possibile assegnare automaticamente un valore alla variabile dichiarata, nella stessa riga in cui definiamo la variabile
stessa:
int NomeVariabile = 0;
Le variabili posso essere di sette categorie:

1 - Local Variable: una variabile è detta locale quando viene dichiarata localmente (dentro la classe), quindi ha effetto solo in
quella classe in cui è stata dichiarata.

2 - Class Variable: le variabili di classe sono dei campi dichiarati utilizzando la parola chiave static in una dichiarazione di
classe, oppure anche con o senza static in una dichiarazione di Interfaccia, una variabile di classe viene creata quando la
classe o l'interfaccia viene dichiarata e termina il suo ciclo di vita insieme alla classe o all'interfaccia.

3 - Instance Variable: le variabili d'istanza sono invece quelle variabili dichiarate dentro una classe senza la parola chiave
static.

4 - Array Components: sono quelle variabili che contengono più di un valore, troverete nel capitolo 7 maggiori informazioni
sugli Array.

5 - Method Parameters: sono delle variabili utilizzate come valori di argomenti che si passano con i Metodi o Funzioni().

6 - Constructor Parameters: ovvero valori di argomenti passati dal Costruttore. Come le proprietà di un oggetto.

7 - Exception-handler Parameters: esistono delle variabili che catturano il tipo di Eccezione (errore gestibile) e ne riportano
l'identificazione.

Esistono anche delle variabili dette Costanti, perchè non possono cambiare il valore impostato alla creazione, vengono definite
costanti quando si applica la parola chiave final.
// esempio di variabile costante
final int numeroCinque = 5;
I tipi di dati si suddividono in Integrali, a Virgola mobile ed Espressivi:

Tipi di dati Integrali:

byte = 8 bit = valori da -128 a 127 incluso

short = 16 bit = da -32768 a 32767 incluso
int = 32 bit = da -2147483648 a 2147483647 incluso
long = 64 bit = da -9223372036854775808 a 9223372036854775807 incluso
char = 16 bit, interi senza segno che rappresentano un carattere Unicode = da '\u0000' a '\uffff'
// esempi

byte VarByte = 100;

short VarShort = 30000;
int VarInt = -2000000000;
long VarLong = 9000000000000;
char VarChar = 'x';
Tipi di dati a Virgola mobile:

float = 32 bit = IEEE 754

double = 64 bit = IEEE 754
// esempi

float VarFloat = 100,5;

double VarDouble = 10000000,5;
Tipi di dati Espressivi

boolean = true || false = vero o falso

// esempio

int x = 5;
int y = 10;
boolean risultatoBinario;

risultatoBinario = (x == y);
System.out.println(risultatoBinario); // restituisce false

risultatoBinario = (x < y);

System.out.println(risultatoBinario); // restituisce true
Una particolare attenzione dobbiamo dare all'oggetto String che contiene una serie di char, ma non essendo un Tipo di dato
andrà dichiarato utilizzando la parola chiave new (che istanzia un nuovo oggetto):
// esempio di oggetto String

String OggettoStringa = new String("Valore testuale ");

OggettoStringa = OggettoStringa + "dell'OggettoStringa";
System.out.println(OggettoStringa);
Avremo come risultato su schermo "Valore testuale dell'OggettoStringa" perchè abbiamo utilizzato l'operatore + per
concatenare le due stringhe.

Naturalmente possiamo anche crearci dei nostri Tipi di dati detti definiti dall'utente, spiegheremo come nel capitolo 8, dedicato
alla Programmazione Orientata agli Oggetti.

Per poter convertire una variabile da un tipo di dato ad un altro, si usa un'operazione chiamata Casting:
// esempio Casting

float f = 2.5;
int i = (int) f;

// converte f in un intero
// escludendo i decimali dichiarato con i
Operatori e Condizioni
Home + Java + Guida Java + Operatori e Condizioni
Naturalmente per poter effettuare delle condizioni, tra le variabili dobbiamo inserire dei caratteri corrispondenti a degli
operatori: esistono Operatori matematici e Operatori di espressione, ne elenchiamo i più usati:

Operatori matematici:
+ addizione (o anche concatenazione di stringe)
- sottrazione
/ divisione
* moltiplicazione
++ incremento
-- decremento
Nota:
per elevare un numero a potenza si utilizza il metodo pow(double a, double b) della classe java.lang.math.
Ad esempio, per elevare il numero 3 al quadrato utilizzeremo:
double potenza = java.lang.math.pow(3,2);
Operatori di espressione:
= assegnazione
== ugualianza
!= differenza
> maggiore
< minore
&& e (AND logico)
|| o (OR logico)
E' possibile concatenare tra loro diversi Operatori per avere significati differenti:
>= maggiore e uguale
<= minore e uguale
+= assegna e aggiunge un valore
-= assegna e sottrae un valore
Facciamo qualche esempio:
int x = 1; // utilizziamo l'operatore = di assegnazione
int y = x + 1; // y sarà uguale a 2
y += 10; // y diventa 12

if (x == y)
{
System.out.println("Primo risultato FALSO");
}
else if (y > x)
{
System.out.println("Secondo risultato VERO");
}
Abbiamo visto come è possibile utilizzare gli operatori, analizziamo ora nel dettaglio cosa sono e come possiamo scrivere le
condizioni in Java: leggendo l'esempio qui sopra riportato vi troviamo una riga con la condizione if, seguita (tra parentesi)
dalla condizione che x deve essere uguale a y. Avrei potuto anche omettere le parentesi graffe, infatti se l'istruzione che segue
è una sola non c'è bisogno di racchiudere in blocco, ma è importante che almeno agli inizi vi abituate ad utilizzarle le parentesi
graffe. Seguendo troviamo la condizione else if, che indica una alternativa determinando una ulteriore condizione (se y è
maggiore di x), anch'essa deve essere seguita da un blocco di graffe, nel caso in cui le istruzioni da eseguire siano maggiori di
una.

Ci sono anche altri modi più abbreviati di scrivere una condizione, ritornando alla nostra secoda classe Temp.java, descritta
nel secondo capitolo, analizziamo quest'altra condizione:
System.out.print(i == 0 ? args[i] : " " + args[i]);

/*
la sintassi è la seguente:
condizione ? istruzione se vera : istruzione se falsa
*/
Se la variabile i è uguale a 0 scrive il contenuto dell'Array args[i], altrimenti scrive prima uno spazio vuoto seguito dal valore
stesso.

Al posto di dover scrivere tantissimi else if è possibile utilizzare il blocco switch:

class ProvaSwitch
{
public static void main(String args[])
{
int k = 10;
switch(k)
{
case 5: System.out.println(" case k = 5");
break;
case 10: System.out.println(" case k = 10");
break;
case 15: System.out.println(" case k = 15");
break;
default: System.out.println(" case default");
}
}
}
In questo caso scriverà in schermo "case k = 10", perchè nel blocco switch troviamo 4 casi, determinati dalla parola chiave
case e seguiti dal valore del caso e dai due punti. Importante dopo tutte le istruzioni prima dell'ultima è l'istruzione break;
che indica al compilatore di non tenere presente cosa c'è scritto sotto e permette di andare avanti. L'ultimo caso non ha
bisogno della parola chiave case perchè è la scelta predefinita, nel caso in cui k non sia ne uguale a 5, ne a 10 e nemmeno a
15.

esercitazioni matematiche

si osservi la seguente classe:

public class robaMatematica {

public static int calcolaFattoriale (int numero) {

int fattoriale = 1;
int i = 1;

do {
fattoriale = fattoriale * i;
i++;
} while (i <= numero);

return fattoriale;
}

public static int calcolaAreaRettangolo (int a, int b) {

return a * b;

esercizio

creare un metodo che calcoli l’area di un quadrato; soluzione:

public static int calcolaAreaQuadrato (int lato) {

return calcolaAreaRettangolo (lato,lato);
}

esercizio

creare un metodo che calcoli l’area di un triangolo dati base e altezza; soluzione:

public static double calcolaAreaTriangolo (int a, int b) {

return (a * b) / 2;
}

esercizio

creare un metodo che calcoli l’area di un triangolo con la formula di Erone; soluzione:

public static double calcolaAreaTriangolo (int a, int b, int c) {

int perimetro = a + b + c;
int semiperimetro = perimetro / 2;

return Math.sqrt(
semiperimetro * (semiperimetro - a) * (semiperimetro - b) * (semiperimetro - c));
}

esercizio
creare un metodo che calcoli l’ipotenusa di un triangolo rettangolo; soluzione:

public static double teoremaDiPitagora (int a, int b) {

return Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
}