Laboratorio di Informatica Applicata

Laboratorio di Programmazione ad Oggetti

Roberto Sassi
Università degli studi di Milano - Dipartimento di tecnologie dell'informazione

• Lez1e2
• Lez3e4
• Lez5e6
• Lez7e8
• Lez9e10
• Lez11e12
• Lez13e14
• Lez15e16
• Lez17e18
• Lez19e20
• Lez21e22
• Lez23e24

Primi passi in Java

Giovedì, 27 Settembre 2007

Ripasso: cosa serve la Java Virtual Machine?

Abbiamo visto che la piattaforma Java si basa su tre componenti principali: Il linguaggio, la libreria di classi e la Java Virtual Machine (JVM).

In Java:

1. Il programmatore [VOI!] studia e prepara un programma in Java;
2. il compilatore Java [javac] "traduce" il programma Java in una classe in ByteCode.
3. ciascuna JVM [una distinta per ogni piattaforma!], ricevuto il messaggio in ByteCode, lo interpreta nel "linguaggio" della macchina locale in modo che possa essere eseguito.

Ripassiamo l'anatomia di un programma Java

Quali sono i componenti principali di un programma Java? Ripassiamoli in questa slide.

Dati

Per quanto ci riguarda, un "dato" è una quantità minimale di informazione che vogliamo elaborare con un nostro programma. Può essere il saldo del nostro conto corrente, il numero di amici che abbiamo invitato alla nostra festa o il colore del gatto del vicino.

Come nell'algebra e in altri linguaggi di programmazione, anche in Java chiamiamo variabile il contenitore simbolico di un certo "dato". Le variabili vengono manipolate con degli operatori che ne modificano il valore. Frasi che coinvolgono variabili ed operatori, vengono chiamate espressioni.

Tipi di dato

Supponiamo di dover preparare un modulo cartaceo da compilare per un sondaggio; (l'utente compilerà il modulo con una penna, nessun computer). L'utente deve inserire il proprio sesso, l'età e la marca delle caramelle preferite. Probabilmente prevederemmo una cosa del genere:

 Sesso: _
 Età: __
 Marca caramelle preferite: ____________________

Infatti, per il sesso basta inserire un carattere, M o F, due numeri per l'età e per la marca preferita, che non conosciamo a priori, lasciamo 20 spazi vuoti. Ciascun dato occuperà un certo "spazio" sul foglio, ad esempio la variabile "Sesso" occuperà uno spazio.

In un programma Java, come del resto in ogni linguaggio di programmazione, i dati vengono immagazzinati in memoria da qualche parte (per oggi non ci preoccuperemo di capire dove). Per ogni variabile viene predisposto lo spazio opportuno: come sul foglio venivano predisposti degli spazi per le lettere scritte a penna, allo stesso modo nella memoria del calcolatore viene riservato un numero di byte adeguato.

Per poter fare questo, Java richiede che venga specificato sempre il tipo di dato che vogliamo sia contenuto in una variabile. Ad esempio:

    int questo;
    short mese;

Il tipo di dato non può essere cambiato nel corso del programma. Java è un linguaggio fortemente tipizzato (non lo sarà affatto il PHP).

Per assegnare un valore ad una variabile si utilizza l’operatore =
Esempio:

  tassoInteresse=0.001;

È possibile dichiarare una variabile e contemporaneamente assegnarle un valore. Esempio:

  int guasti=10;

I nomi delle variabili (ma anche di classi ed oggetti che vedremo più avanti nel corso) si chiamano identificativi. Un identificatore deve rispettare le regole:

• deve iniziare con una lettera: A-Z, a-z, _, $, e lettere Unicode
• può contenere lettere e numeri ma non spazi
• è “case sensitive”: maiuscolo e minuscolo fanno differenza (a e A, Pippo1 e pippo1 sono diversi)
• non può essere una parola riservata Java (keyword: ad esempio if, else, while) né null, true o false.

Riassumendo, in Java una variabile è un dato a cui si fa riferimento tramite un identificativo. Inoltre:

• due variabili non possono avere lo stesso identificativo all’interno dello stesso contesto (vedremo in dettaglio cosa sia)
• (Per convenzione, regola generale) l’identificativo di una variabile inizia sempre con una lettera minuscola ed è composto solo da lettere minuscole. Ad esempio: sensore, contatore
• (Per convenzione, caso particolare) se l’identificativo di una variabile è composto da più parole, dalla seconda in poi le si inizia con la lettera maiuscola. Ad es: reattoreNucleare, scorieRadiottiveIncombuste

Il tipo di una variabile ne indica il formato del contenuto ed le operazioni che possono essere effettuate. Java prevede due categorie di tipi di dato:

• Primitivi (primitive, ad esempio un intero);
• Riferimento ad Oggetto (reference).

Tipi di dati primitivi

In Java, i tipi di dati primitivi sono i mattoni base a partire dai quali vengono costruiti tutti gli altri oggetti. NON sono oggetti. Sono stati pensati a partire da quelli definiti dal C, con alcuni miglioramenti e semplificazioni efficaci. Eccoli:

Il valore di default verrà utilizzato per i campi degli oggetti e per gli array [per adesso non sappiamo cosa siano; lo capiremo più avanti].

Valori logici

In Java assumono i valori true o false e NON sono dei numeri interi ne possono essere convertiti in numeri interi come succede in C o C++.

Interi

I numeri interi sono tutti con il segno. NON esistono i numeri unsigned come in C. Inoltre hanno una dimensione che è fissata dal linguaggio (quella della tabella sopra) e non variabile con il tipo di architettura.

I numeri vengono rappresentati in base 2 e non in base decimale. Questo perché, come ben sapete, le memorie sono bistato e possono solo memorizzare due valori, che per convenzione si assumono essere 0 o 1.

        155/2 = 77/2 = 38/2 = 19/2 = 9/2 = 4/2 = 2/2 = 1/2 = 0
          1      1      0      1     1     0     0     1
        <--- Leggiamo i resti in questa direzione -----
        10011011
        

        155/16 = 9/16 = 0
         11      9
        <--- Leggiamo i resti in questa direzione -----
        9B
        

        10011011 = 1*2^7 + 0*2^6 + 0*2^5 + 1*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 1*2^0 =
                 = 1*128 + 0* 64 + 0* 32 + 1* 16 + 1*  8 + 0*  4 + 1*  2 + 1*  1 =
                 =   128 +     0 +     0 +    16 +     8 +     0 +     2 +     1 =
                 = 155
        (il simbolo ^ indica qui l'elevamento a potenza, ma non è un operatore JAVA!)
        

        10011011 --> 1001 e 1011
                     8+0+0+1 e 8+0+2+1
                     9 e B
                     9B
                     9B
        

        155 è un intero, quindi sarà contenuto in 32 bits:
        00000000 00000000 00000000 10011011
        invertiamo tutti i bits
        11111111 11111111 11111111 01100100
        

        ~155 + 1 =
                   11111111 11111111 11111111 01100100 +
                   00000000 00000000 00000000 00000001 =

                   11111111 11111111 11111111 01100101
        

         155 -->   00000000 00000000 00000000 10011011 +
        -155 -->   11111111 11111111 11111111 01100101 +

                   00000000 00000000 00000000 00000000
        

         32767 è uno short, dunque è memorizzato in 16 bits
         32767 -->   01111111 11111111 +
             1 -->   00000000 00000001 =

                     10000000 00000000 
        

class EsempioCircolarita {
  public static void main(String[] args) {
    short a = 32767;
    a += 1;
    System.out.println(a);
    short b = -32768;
    b -= 1;
    System.out.println(b);
  }
}

>java EsempioCircolarita
-32768
32767

Nei nostri programmi utilizzeremo solo numeri interi di tipo int e long, visto che per quanto ci riguarda possiamo fare a meno delle altre tipologie.

Numeri a virgola mobile

I numeri a virgola mobile sono una rappresentazione dei numeri razionali. NON sono un insieme denso cioè tra due numeri non è detto che ce ne sia un terzo né sono illimitati.

L'aritmetica a virgola mobile di Java è un sottoinsieme dello standard IEEE-754. Per i più curiosi, all'indirizzo http://www.h-schmidt.net/FloatApplet/IEEE754.html potete trovare un applet Java che vi permette di capire meglio la rappresentazione in virgola mobile.

Durante il corso utilizzaremo solo numeri a virgola mobile di tipo double (64 bits).

Caratteri

 NUL(  0)    SOH(  1)    STX(  2)    ETX(  3)
 EOT(  4)    ENQ(  5)    ACK(  6)    BEL(  7)
 BS (  8)    HT (  9)    NL ( 10)    VT ( 11)
 FF ( 12)    CR ( 13)    SO ( 14)    SI ( 15)
 DLE( 16)    DC1( 17)    DC2( 18)    DC3( 19)
 DC4( 20)    NAK( 21)    SYN( 22)    ETB( 23)
 CAN( 24)    EM ( 25)    SUB( 26)    ESC( 27)
 FS ( 28)    GS ( 29)    RS ( 30)    US ( 31)
 SP ( 32)     ! ( 33)     " ( 34)     # ( 35)
  $ ( 36)     % ( 37)     & ( 38)     ' ( 39)
  ( ( 40)     ) ( 41)     * ( 42)     + ( 43)
  , ( 44)     - ( 45)     . ( 46)     / ( 47)
  0 ( 48)     1 ( 49)     2 ( 50)     3 ( 51)
  4 ( 52)     5 ( 53)     6 ( 54)     7 ( 55)
  8 ( 56)     9 ( 57)     : ( 58)     ; ( 59)
  < ( 60)     = ( 61)     > ( 62)     ? ( 63)
  @ ( 64)     A ( 65)     B ( 66)     C ( 67)
  D ( 68)     E ( 69)     F ( 70)     G ( 71)
  H ( 72)     I ( 73)     J ( 74)     K ( 75)
  L ( 76)     M ( 77)     N ( 78)     O ( 79)
  P ( 80)     Q ( 81)     R ( 82)     S ( 83)
  T ( 84)     U ( 85)     V ( 86)     W ( 87)
  X ( 88)     Y ( 89)     Z ( 90)     [ ( 91)
  \ ( 92)     ] ( 93)     ^ ( 94)     _ ( 95)
  ` ( 96)     a ( 97)     b ( 98)     c ( 99)
  d (100)     e (101)     f (102)     g (103)
  h (104)     i (105)     j (106)     k (107)
  l (108)     m (109)     n (110)     o (111)
  p (112)     q (113)     r (114)     s (115)
  t (116)     u (117)     v (118)     w (119)
  x (120)     y (121)     z (122)     { (123)
  | (124)     } (125)     ~ (126)    DEL(127)

I caratteri in Java sono codificati seguendo lo standard di codifica UCS-2 (che è un sottoinsieme di UTF-16) capace di codificare tutti i caratteri del "basic multilingual plane" con 16 bits. In Java dunque per ciascun carattere sono utilizzati due bytes (NON uno come in C). Questo permette di includere pressoché qualunque tipo di carattere utilizzato sulla terra (ma non tutti gli ideogrammi cinesi per i quali serve utilizzare una codifica a 32 bits UTF-16. Ne vedremo un accenno più avanti).

Per rappresentare una costante carattere la si deve includere tra due apici semplici. Per assegnare un carattere unicode ad una variabile si utilizza la forma \uXXXX dove XXXX è la codifica esadecimale. Comode sone le seguenze di escape, come in C:

Esempi:

    char carattere = 'R';
    char carattere = '\n';
    char carattere = '\u05D0';    

Conversione tra tipi differenti

Talvolta è necessario mischiare valori numerici:

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

Quando viene svolta operazione con dati di tipo diverso:

• se uno degli operandi è un double anche l’altro viene convertito in double
• Altrimenti, se uno degli operandi è un float, anche l’altro viene convertito in float
• Altrimenti, se uno degli operandi è un long, anche l’altro viene convertito in long
• Altrimenti, entrambi gli operandi vengono convertiti in un intero.

Casting

Il Java ha un controllo dei tipi molto più stringente che il C. Permette conversioni di tipo implicite SOLO quando è impossibile perdere informazioni. E’ possibile passare implicitamente da una variabile “meno capiente” ad una “più capiente” (es. da int a long). Non il viceversa. Altrimenti, se si vuole forzare la conversione di tipo dobbiamo forzarla, come in C, con un cast. Esempio:

    long numeroLungo = 35267;
    int numeroCorto;
    numeroCorto = (int)numeroLungo;

La seguente è la tabella delle conversioni implicite ammesse:

Costanti letterali

Ogni tipo è dotato di costanti letterali: permettono di rappresentare i valori constanti per ogni tipo.

Ne abbiamo (senza saperlo) già viste molte:

int contatore = 1;
double tassoInteresse = 3.4;
boolean esameSuperato = true;
char carattere = 'R'; 
char carattere = '\n'; 
char carattere = '\u05D0';
long numeroLungo = 323423423L

Operatori

Gli operatori vengono utilizzati per effettuare operazioni su variabili o costanti letterali. Sono di tre tipi:

• unari: richiedono un solo operando
  • notazione prefissa: operatore operando

    ++ i;
    

  • notazione postfissa: operando operatore

    i ++; 
    

• binari: richiedono due operandi. Si utilizza solo la notazione infissa: operando operatore operando
• ternari: richiedono tre operandi. Si utilizza solo la notazione infissa: operando operatore operando
  In Java l’unico operatore ternario è l’operatore condizionale ?: (funziona approssimativamente come un costrutto if-then-else; lo vedremo in seguito)

Una buona notizia: gli operatori Java coincidono pressoché con quelli C/C++.

Aritmetici

Somma (+), sottrazione (-), moltiplicazione (*), divisione (/) e resto della divisione intera (%). ATTENZIONE: se la divisione è fatta tra due interi NON produce un numero a virgola mobile!

Operatori di auto-incremento:

• a++ (post-incremento) -> a = a + 1 [unario postfisso]
• ++a (pre-incremento) -> a = a + 1 [unario prefisso]

auto-decremento

• a-- (post-incremento) -> a = a – 1 [unario postfisso]
• --a (pre-incremento) -> a = a – 1 [unario prefisso]

Che differenza c'è tra operatori di pre-incremento e post-incremento?

int i=10;
int b = 10 * i++; 
// corrisponde a: int b = 10 * i; i = i + 1;
int b = 10 * (++i); 
// corrisponde a: i = i + 1; int b = 10 * i; 

Gli operatori aritmetici possono essere utilizzati con operandi di tipo char. Il valore su cui vengono effettuate le operazioni aritmetiche è il codice Unicode corrispondente. Esempio:

int  a = 5 * ‘r’; 
equivalente a:
int  a = 5 * 114;

Assegnamento

L'operatore di assegnamento è il segno di uguale (=). Come in C, la maggior parte degli operatori può essere combinata con l'operatore di assegnamento. Ad esempio, a += 3; corrisponde a a = a + 3;.

Relazionali

Uguale (==), diverso (!=), maggiore (>), maggiore e uguale (>=), minore (<) e minore e uguale (<=). Restituiscono il valore boolean true se la relazione è verificata, false altrimenti.

Logici

Operano su due operandi boolean e restituiscono un valore boolean. not (!) [unario prefisso], and (&&) [binario], or (||) [binario] e xor (^) [binario].

&& e || sono operatori “short-circuit”: il secondo operando è valutato solo se necessario.

op1 && op2 // se op1 è false, op2 non viene valutato
op1 || op2 // se op1 è true, op2 non viene valutato

Esistono anche gli operatori logici: & (unconditional and) e | (unconditional or) che non sono “short-circuit” (op1 e op2 sono comunque valutati). Sono sconsigliati!

Commenti

In Java è possibile inserire commenti nel codice in tre modi. I primi due sono identici a quelli previsti dal C++. Esempio:

  /* Questo è 
  un commento
  su 
  più righe. */

  // Questo è un commento a singola riga

Il terzo modo serve per specificare dettagli di un programma agli altri programmatori (o anche a noi stessi). Lo vederemo più avanti.

Stringhe

Le stringhe NON sono un tipo di dato primitivo ma un oggetto della classe String. Mnemonicamente potete ricordare che String inizia con una maiuscola, come del resto tutte le classi, a differenza dei tipi primitivi che iniziano con una minuscola.

Le stringhe però a differenza di quasi tutti gli altri oggetti possono essere inizializzate con una costante letterale, come in C. Esempio:

    String frase = "Questa è una stringa";

Le stringhe sono terminate da un carattere NULL come in C? Non ci interessa come siano rappresentate nella memoria. Questo è un tipico della programmazione ad oggetti e si chiama "incapsulazione": nascondere i dettagli implementativi.

Concatenamento stinghe

L'operatore + quando usato con due stringhe le concatena. Esempio:

    String nome = "Luigi" + " " + "Rossi";

Istruzioni e blocchi

Una istruzione in Java coincide con un comando eseguito dalla JVM. Un blocco è un insieme di istruzioni racchiuso tra parentesi graffe. E' possibile dichiarare delle variabili locali all'interno di in blocco di istruzioni, e non è necessario farlo all'inizio come in C89. I blocchi possono essere annidati a piacere: le variabili locali sono visibili dal punto della loro dichiarazione fino alla fine del blocco cui appartengono, (quindi anche nei sottoblocchi). (Queste sono chiamate in genere regole di scopo o di visibilità).

  int a = 1;
  {
    int b;
    b = a; // b diventa 1
  } // qui la variabile b cessa di esistere
 

Una sequenza è invece una banale successione di istruzioni.

Strutture di controllo del flusso 1/4

Strutture condizionali: if

Composta da UNA espressione e UNO/DUE/TRE blocchi di codice (chiamati i "rami" dell' if)

if (condizioneLogica)
  istruzione1;
 

oppure

if (condizioneLogica)
  istruzione1;
else
  istruzione2;
 

oppure

if (condizioneLogica1)
  istruzione1;
else if (condizioneLogica2)
  istruzione2;
else if (condizioneLogica3)
  istruzione3;
else
  istruzione4;
 

Ciuscuna istruzione può essere costituita da un istruzione singola o da un blocco. Attenzione! Il costrutto else si riferisce SEMPRE al istruzione if più vicino:

if (condizioneLogica1)
  if (condizioneLogica2)
    if (condizioneLogica3)
else
  istruzione;
 

In questo codice, indentato male appositamente, il costrutto else è legato alla condizioneLogica3.

Lab

import javax.swing.*;

class Somma {
  public static void main(String[] args) {
    String stringaInput;
    int primoNumero, secondoNumero;

    stringaInput = JOptionPane.showInputDialog("Inserisci il primo numero");
    primoNumero = Integer.parseInt(stringaInput);

    stringaInput = JOptionPane.showInputDialog("Inserisci il secondo numero");
    secondoNumero = Integer.parseInt(stringaInput);

    JOptionPane.showMessageDialog(null, "La somma dei due numeri è " +
      (primoNumero+secondoNumero));

    System.exit(0);
  }
}