Corso Programmazione Java Base

Corso
Programmazione Java Base
Modulo 3: Sintassi Elementare

Leggi il programma completo del corso

Agenda
Cap 1 - Introduzione
Cap 2 - Ciclo di sviluppo
►Cap 3 - Sintassi Elementare◄
Cap 4 - Principi OOP
Cap 5 - Classi e Oggetti
Cap 6 - Concetti Object Oriented
Cap 7 - Collections
Cap 8 - Eccezioni
Cap 9 - Input Output
Cap 10 - Serialization
Cap 11 - Unit Testing
Cap 12 - Threads

www.javaportal.it | www.k-tech.it corsi@k-tech.it 2

Tipi primitivi

Esistono otto tipi di dati fondamentali predefiniti, rappresentano numeri,
caratteri e valori logici.
I tipi primitivi sono diversi dalle classi.

Tipo Dimensione Intervallo di valori
boolean 1 bit true o false
char 16 bit carattere unicode
byte 8 bit [-128, 127]
short 16 bit [-32768, 32767]
int 32 bit [-2147483648, 2147483647]
long 64 bit [-9223372036854775808,9223372036854775807]
float 32 bit [-3.4E38, 3.4E38]
double 64 bit [-1.7E308, 1.7E308]


Casting tipi primitivi

Casting: Conversione di tipo
Casting implicito: senza perdita di precisione se si segue la gerarchia:

byte short int long float double

byte i = 100;
long k = i*3 + 4;
double d = i * 3.1 + k /2;

Casting esplicito: è una conversione forzata con perdita di precisione.
float f = (float) 10.1;
int i = (int) f;


Classi Wrapper

Per ogni tipo primitivo esiste una classe wrapper.

Tipo Primitivo Classe Wrapper
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double


Autoboxing

Boxing conversion
– E' il “meccanismo” per cui un tipo primitivo viene convertito in
una istanza del corrispondente tipo Wrapper con lo stesso
valore. La conversione può avvenire in modo automatico.

Integer val = 3;

Unboxing conversion
– E' il “meccanismo” per estrarre il valore di un tipo primitivo
dalla corrispondente istanza Wrapper.
int x = val;

int x = val.intValue();


Tipi enumerati...

Sono stati introdotti nella versione JDK 5.0.
Un tipo enumerato consente un numero finito di valori nominali.
Si definiscono attraverso la parola chiave enum:
Size.java
Size s = Size.MEDIUM;
public enum Size {SMALL,MEDIUM,LARGE;}

Il tipo definito sopra è in effetti una classe, che ha esattamente le tre
istanze specificate.
Una enumerazione non si può estendere, né può estendere un’altra
enum o un'altra classe.
È invece possibile far implementare un’interfaccia ad un’enum.


...Tipi Enumerati
Essendo le enumerazioni trasformate, dal compilatore, in classi che estendono la
classe java.lang.Enum è possibile utilizzare i metodi di tale classe oppure farene
l’overriding.
int x = Size.SMALL.ordinal(); // x <- 0
String s = Size.LARGE.toString(); // s <- “LARGE”

Possiamo fornire una enumerazione di costruttori e metodi:

Size.java
public enum Size {
SMALL(“S”), MEDIUM(“M”), LARGE(“L”);
private String abbrev;
private Size(String abbrev){ this.abbrev = abbrev; }
public String getAbbrevazione() { return abbrev; }
}

Ogni tipo enumerato prevede un metodo statico che restituisce un contenete i valori
dell’enumerazione:
Size[] values = Size.values();


Parole chiave
In un programma, per quanto semplice, incontriamo delle parole chiave.
HelloWorld.java
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello, World!");
}
}

Impareremo quando e come si utilizzano alcune di queste parole chiave.
abstract default goto null synchronized
boolean do if package this
break double implements private throw
byte else import protected throws
case extends instanceof public transient
catch false int return true
char final interface short try
class finally long static void
const float native super while
continue for new switch enum


Dichiarazione di variabili
Java è un linguaggio fortemente tipizzato => non è possibile utilizzare una variabile senza
dichiararla.

Tipi di dichiarazione valide: Tipi di dichiarazione errate:
• int _a; • int :b;
• int $c; • int -d;
• int ______2_w; • int e#;
• int _$; • int .f;
• int 7g;
Classi e Interfacce: Iniziale Maiuscolo e secondo convenzione CamelCase
●Automobile, Persona, PrintWriter...
Metodi: Iniziale in minuscolo e se composta l'iniziale della seconda parola maiscolo
● calcolaBudget(), getNome(), accelera()...
Variabili: Stessa regola dei metodi
●colore, nome, budget...
Costanti: Tutto in Maiuscolo e se composta le parole separate con “_”
● MINIMO_PESO, MASSIMA_VELOCITA...


Dichiarazioni e assegnazioni
int a; // dichiarazione
a ?

a = 5; // assegnazione
a 5

float b = 3.6f; // dichiarazione e assegnazione

new Auto(); // crea un'istanza della classe Auto
?

Auto vettura = new Auto(); // dichiarazione e assegnazione
vettura
?


Operatori…

Cosa sono:
Un operatore è un componente di base che compie operazioni su uno o
più operandi.
a = b + c

Perché si usano:
Gli operatori si usano per manipolare dati oppure per eseguire delle
scelte attraverso l’esecuzione di comandi di controllo.

if (a==b){
//esegui blocco1
a = b + c }
else{
// esegui blocco2
}


…Operatori…

Quando si usano:
Gli operatori possono essere utilizzati sia quando gli operandi sono tipi
primitivi, sia quando gli operandi sono oggetti (con delle limitazioni).

int a,b,c;
a = b + c Long num = new Long(4)


…Operatori

Classificazione
Gli operatori possono essere classificati in base a:
● numero di operandi
● tipo di operazione

Classificazione sul numero di operandi:
● operatori unari
++x ; x++; y--; --y
● operatori binari
b + c; a = 5
● operatore ternario
espressione_test ? azione_true : azione_false;


Operatore ternario

int a = 5;
int sign = a > 0 ? 1 : -1;

// o meglio

int sign = a > 0 ? 1 : (a == 0 ? 0 : -1) ;

// è equivalente a

int sign;
if (a > 0)
sign = 1;
else if (a == 0)
sign = 0;
else
sign = -1;


Operatori

Classificazione in base al tipo di operazione:
● operatori aritmetici (+, -, /, *,%)
● operatori di confronto (==, !=,>,<,>=,<=)
● operatori sui bit (>>, <<)
● operatori di assegnazione (=, +=, -=, /=,…)
● operatori di concatenamento (+ tra stringhe)
● operatore di condizionamento (?:)
● operatori di conversione ( casting )
● operatori logici (&&, ||, !, &, |,^, ~)


Operatori Logici

Tabella delle operazioni logiche

A B A&&B A||B !A
false false false false true
true false false true false
false true false true true
true true true true false

A B A&B A|B A^B ~A
00 00 00 00 00 11
00 01 00 01 01 11
00 10 00 10 10 11
00 11 00 11 11 11 Tabella delle operazioni logiche sui bit
01 00 00 01 01 10
... ... ... ... ... ... A B A>>B A<<B
11 11 11 11 00 00 0001100 01 0000110 0011000


Priorità Operatori
Priorità Tipo Operazione
1 Op++ op--
2 ++op --op ~ !
3 */%
4 +-
5 << >>
6 > < <= >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?:
14 = += -= *= /= %= &= ^= |= <<= >>=


Esempio di Javadoc
Automobile.java
/**
* Classe Automobile
*
* @author serf
*
*/
public class Automobile {
private String colore; private double velocitaMassima;
private double velocitaIstantanea; private int cilindrata;
public Automobile(double velocitaMassima, String colore, int cilindrata) {
this.velocitaMassima = velocitaMassima; this.colore = colore;
this.cilindrata = cilindrata;
}
/**
* Incrementa l'attributo 'velocitaIstantanea'.
*
* @param dv valore di cui incrementare la 'velocitaIstantanea'.
*/
public void accelera(int dv) { velocitaIstantanea = velocitaIstantanea + dv; }
/**
* Decrementa l'attributo 'velocitaIstantanea'.
*
* @param dv valore di cui decrementare la 'velocitaIstantanea'.
*/
public void decelera(int dv) { velocitaIstantanea = velocitaIstantanea - dv; }
public void sterza() { //... }
}


Esempio di Javadoc
Automobile.java
/**
* Classe Automobile
*
* @author serf
*
*/
Generato
private String colore; private double velocitaMassima;
automaticamente
private double velocitaIstantanea; private int cilindrata;
public Automobile(double velocitaMassima, String colore, int cilindrata) {

da Javadoc!
this.velocitaMassima = velocitaMassima; this.colore = colore;
this.cilindrata = cilindrata;
}
/**
* Incrementa l'attributo 'velocitaIstantanea'.
*
* @param dv valore di cui incrementare la 'velocitaIstantanea'.
*/
public void accelera(int dv) { velocitaIstantanea = velocitaIstantanea + dv; }
/**
* Decrementa l'attributo 'velocitaIstantanea'.
*
* @param dv valore di cui decrementare la 'velocitaIstantanea'.
*/
public void decelera(int dv) { velocitaIstantanea = velocitaIstantanea - dv; }
public void sterza() { //... }
}


Flussi di Controllo...

Cosa sono:
Sono istruzioni particolari che regolano il flusso di esecuzione di una
applicazione.

Perché si usano:
Si usano per eseguire selettivamente blocchi di istruzioni di oppure
iterativamente blocchi di istruzione.

if(espressione1){
while (espressione1){ //esegui blocco1
// esegui blocco1 }
} else{
// esegui blocco2
}


...Flussi di Controllo

Quando si usano:
Vengono utilizzati quando vogliamo forzare l’esecuzione di un
determinato blocco di istruzioni all’interno dell’applicazione.

Classificazione
Le istruzioni di controllo possono essere classificati in:
● istruzioni condizionali
● istruzioni iterative if else; switch case default;

while; do while; for; for each


Istruzioni condizionali…

Le istruzioni condizionali permettono, durante la fase runtime, di
vincolare l’esecuzione di un blocco di istruzione a una condizione
booleana.

Costrutto if else
Il costrutto più usato in Java è l’“if ”

if( condizione){
// blocco istruzioni1;
}
else{
// blocco istruzioni2;
}


…Istruzioni condizionali

Costrutto switch-case-default
Il costrutto “switch case default” viene utilizzato come alternativa al
costrutto if, qualora si voglia seguire un percorso differente a seconda
del valore assunto da una espressione.

switch(<espressione intera>){
case (<valore costante 1>):
//...( <sequenza di istruzioni>)
break;
case (<valore costante 2>)
break;
//....
//....
default:
// è opzionale
}


Istruzioni iterative...

Le istruzioni iterative permettono, durante la fase runtime, di impostare la
ripetizione di un insieme di istruzioni.
Le istruzioni iterative possono essere determinate quando è noto il
numero di iterazioni, indeterminate viceversa.

Costrutto while
Il costrutto while è tra quelli che determina un numero di iterazioni
indeterminato.
La notazione per rappresentare tale costrutto è la seguente:

while( condizione di permanenza){
// blocco istruzioni;
}


…Istruzioni iterative…

Costrutto do-while
Anche il costrutto do- while è tra quelli che determina un numero di
iterazioni indeterminato.
La sua notazione è la seguente:

do{
// blocco istruzioni;
}while( condizione di permanenza);

La differenza con il costrutto while è che il blocco di istruzioni viene
eseguito almeno una volta prima di verificare la condizione.


…Istruzioni iterative…

Costrutto for
Il costrutto for è tra quelli che determina un numero di iterazioni
determinato.


for( int i=0; i<10; i++){
// blocco di istruzioni;
}


...Istruzioni iterative

Costrutto for each
Anche il costrutto for each è tra quelli che determina un numero di
iterazioni determinato.

for (variabile_temporanea : oggetto_iterabile)
{
//blocco istruzioni;
}

public int sum(int[] a) {
int result = 0;
for (int i : a)
result += i;
return result;
}


Array…

Sequenza di dati del medesimo tipo accessibile tramite indice.

fonte SUN Java Tutorial


…Array…

Alcuni esempi

Strumento.java
public class Strumento {//… }

int[] a = new int[10]; // array di interi
int b[]; // array di interi, sintassi equivalente
Strumento[] s; // array di tipo Strumento
s = new Strumento[15]; // assegnazione

a[0] = 1; a[1] = 2; a[9] = 10;

a[10] = 1; // genera un ArrayOutOfBound exception

s[7] = new Strumento(); s[8] = new Strumento();


…Array

Sintassi “abbreviata”

int[] arrayOfInt = {10, 20, 30, 40, 50, 60};
// è equivalente a
int[] arrayOfInt = new int[6];
arrayOfInt[0] = 10; arrayOfInt[1] = 20; arrayOfInt[2] = 30;
arrayOfInt[3] = 40; arrayOfInt[4] = 50; arrayOfInt[5] = 60;

String[][] names = {{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}};
System.out.println(names[0][0] + names[1][0]); //Mr. Smith
System.out.println(names[0][2] + names[1][1]); //Ms. Jones

fonte SUN Java Tutorial


Scope delle variabili...

Lo scope di una variabile: visibilità di una variabile, cioè la parte di
programma in cui quella variabile può essere referenziata, inizia con la
dichiarazione e finisce con la chiusura del blocco.

Le variabili possono essere dichiarate a livello di:
● loop: visibilità solo nel ciclo;
● metodo: visibilità in tutto il corpo del metodo;
● classe: visibilità in qualunque parte del codice.


...Scope delle variabili...

Automobile.java
private String color;
private int velocita;
...
public Automobile(){…}
public String modificaColore(String col){
String colore = col;
if(!(color.equals(colore)))
color=colore;
return color;
}
public void accelera(){

for(int i=0;i<100;i++){
velocita= velocita+i;
}
}
...
}


...Scope delle variabili


Ricorsione...

Cos'è la ricorsione?
La ricorsione è una tecnica di programmazione in cui una funzione
richiama se stessa.

Quando viene utilizzata?
Per risolvere problemi computazionalmente complessi scomponendoli in
problemi più piccoli.


...Ricorsione

Come funziona?
La ricorsione si basa sul principio di induzione matematica.

L'approccio ricorsivo prevede:
l'identificazione di un caso base: soluzione nota esprimere la soluzione al
caso generico n scomponendolo in problemi più piccoli dello stesso tipo.

Nota:
La soluzione nota rappresenta la condizione d'uscita della ricorsione,
l'elemento base in cui bisogna scomporre il problema complesso.
Identificare la soluzione nota è importante per evitare di entrare in una
ricorsione infinita. Una ricorsione infinita può provocare l'esaurimento
della memoria e generare uno stack overflow error.


Efficienza della ricorsione

La ricorsione può essere uno strumento potente per realizzare algoritmi
complessi.
La ricorsione può portare ad algoritmi con cattive prestazioni (inefficienti).
Esistono casi in cui il metodo iterativo è più efficiente del metodo
ricorsivo.


Esempio Fattoriale...

Consideriamo il fattoriale di un numero n:

n!=n*(n-1)*(n-2)*...*2*1

Supponiamo n=4

4!=4*(3)! 3!=3*(2)! 2!=2*1!
1!=1 condizione
4!= 4 3 2 1 d'uscita

4!=4*6 3!=3*2 2!=2*1


...Esempio Fattoriale

L'esempio sottostante mostra l'implementazione calcolo fattoriale in
Java:

public int fat(int n){
if(n<=1)
return 1;
else
return n*fat(n-1);
}


Classe System...

La classe System contiene funzionalità per le seguenti diverse aree:
● Standard I/O handles
– InputStream in, PrintStream out e err
● Manipolare le proprietà di sistema
– getProperties()
– getProperty(String chiave)
– setProperty(String chiave, String valore)
– setProperty(Properties proprieta)
– clearProperty(String chiave)
– ...


...Classe System...

● Utility per il Runtime corrente
– arraycopy()
– currentTimeMills()

– exit()

– gc()
● Security
– setSecurityManager(SecurityManager s)


...Classe System

E' possibile utilizzare la classe System come logger dell'applicazione:

public class ElencoCorsi {
public static void main(String[] args) throws Exception {
File outputFile = new File("/home/k_tech/elencoCorsi.txt");
OutputStream fout = new FileOutputStream(outputFile);
PrintStream pStream = new PrintStream (fout);
System.setOut(pStream);
FileOutput foutput = new FileOutput();
List elenco_corsi= new ArrayList();
elenco_corsi.add("java_base");
elenco_corsi.add("java_avanzato");
elenco_corsi.add("ing_requisiti");
elenco_corsi.add("ooad");
Iterator it = elenco_corsi.iterator();
while(it.hasNext()){
String nomeCorso =it.next().toString();
System.out.println(nomeCorso);
}
pStream.close();
fout.close();
}
}


Annotation...

Cosa sono?
Sono dei metadati (informazioni aggiuntive) associate a diverse parti del
codice, che possono essere riutilizzate in diversi modi.

Perché si usano?
Si usano per fornire informazioni:
● al compilatore;
● durante il processo a tempo di compilazione o di deploy;
● durante il processo a runtime.


...Annotation...

Come si usano?
Java fornisce pochi tipi di annotation predefiniti da usare come istruzioni
verso il compilatore, tra questi ci sono:
● @Deprecated
● @Override
● @SuppressWarning
Esiste una politica di accesso alle annotation, a cui corrispondono i
seguenti valori:
● SOURCE: visibile solo nel file sorgente, scartata dal compilatore
quando produce il file binario;
●
CLASS: è presente nel file binario, ma non disponibile a runtime;
● RUNTIME: è presente nel file binario e disponibile a runtime.


...Annotation
Come si scrivono le annotation personali?
/*-------- Login.java
Created: 10/06/2009
Created by: K-tech
----------*/
public class Login {
//...
}

ClassInfo.java
@interface ClassInfo {
String created();
String createdBy();
}

Login.java
@ClassInfo (
created = "10/06/2009",
createdBy = "K-tech",
)
public class Login {
// ...
}


BREAK

Dopo la pausa:

Principi OOP

Leggi il programma completo del corso


Corso Programmazione Java Base

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Corso Programmazione Java Base

Similar a Corso Programmazione Java Base (20)

Más de K-Tech Formazione

Más de K-Tech Formazione (8)

Corso Programmazione Java Base