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

Oggetti e Classi

Giovedì, 16 Ottobre 2008

Ragionare per oggetti

Che cosa è un oggetto software? E cosa una classe? Vediamolo insieme in queste slides.

Cosa è un oggetto?

Per completare la nostra conoscenza di cosa sia un oggetto software, ecco alcune definizioni prese dal libro "Thinking in Java", 3rd ed. di Bruce Eckel. Il libro può essere scaricato direttamente dal sito dell'autore (è un ottimo libro).

In Java abbiamo visto esistono tipi di dati primitivi e oggetti. In definitiva, i tipi di dati primitivi sono definiti dal linguaggio e di certo non ne possiamo aggiungere altri. Per scrivere i nostri programmi possiamo invece ideare nuovi oggetti!

Un primo esempio

class ContoBancario {
  // Variabili istanza:
  private double saldo;

  // Metodi istanza:
  // costruttore predefinito
  public ContoBancario() {
    this.saldo = 0.0;
  }
  // costruttore alternativo
  public ContoBancario(double sommaIniziale) {
    this.saldo = sommaIniziale;
  }

  public double saldoConto() {
    return this.saldo;
  }

  public void deposita(double sommaDepositata) {
    this.saldo += sommaDepositata;
  }

  public void preleva(double sommaPrelevata) {
    this.saldo -= sommaPrelevata;
  }
}

class ProvaConto0 {
  public static void main(String[] args) {
    ContoBancario contoLuigi = new ContoBancario();
    ContoBancario contoGino = new ContoBancario(1000.0);

    // Trasferiamo 100.0 dal conto di Gino a quello di Luigi
    contoGino.preleva(100.0);
    contoLuigi.deposita(100.0);

    System.out.println("Saldo di Gino: " + contoGino.saldoConto());
    System.out.println("Saldo di Luigi: " + contoLuigi.saldoConto());
  }
}

Analizziamo il primo esempio in queste slides. Una sintesi è riportata nei paragrafi che seguono. Questo che stiamo affrontando è un argomento importante: fate anche riferimento al libro di testo!

Variabili e metodi istanza

Lo stato di un oggetto è "contenuto" in particolari variabili dette campi o variabili istanza.

I metodi istanza sono l'interfaccia dell'oggetto verso altri oggetti. Ne definiscono il comportamento. Per invitare un oggetto a manifestare un comportamento (invocare un metodo), si utilizza la notazione:

    nomeOggetto.nomeMetodoIstanza(eventualiArgomentiDelMetodoIstanza);

Il nome dell'oggetto e quello del suo metodo che vorremmo venisse invocato sono separati da un . punto.

Un metodo istanza ha sempre:

• un nome seguito da una coppia di parentesi tonde!
• una serie di argomenti che devono essere forniti al metodo. Sono detti parametri espliciti e vengono contenuti tra le parentesi tonde. Ciscun parametro è preceduto dal suo tipo.
• una coppia di parentesi graffe che seguono il nome e che contengono le istruzioni che il metodo deve eseguire.
• il tipo di dato che il metodo restituisce (un oggetto, un tipo primitivo o void se non restituisce niente).
• se l'oggetto non restituisce void, il metodo deve restituire il dato opportuno attraverso la parola chiave return. Ad esempio: return 10.0;.
• un parametro implicito, cioè il riferimento all'oggetto che lo ha invocato. In Java si indica con la parola chiave this.

Costruttori

Particolari metodi sono detti costruttori e hanno lo stesso nome della classe (identico). Sono metodi che sono preposti all'inizializzazione degli oggetti una volta che sono stati creati dalla JVM.

È tipico utilizzare l'overload cioè avere più costruttori con lo stesso nome (anche perché non potrebbe essere diversamente, visto che il metodo costruttore deve avere lo stesso nome della classe) e con differenti parametri espliciti. Il compilatore Java selezionerà il metodo opportuno a partire dalla chiamata al metodo. Cioè: se il costruttore verrà invocato con nessun parametro, allora il compilatore selezionerà il primo, se il parametro sarà invece uno, verrà invocato il secondo.

All'interno dei costruttori, come nei metodi di istanza è possibile utilizzare il parametro implicito this.

Specificatori di Accesso

Costruendo il nostro oggetto non vogliamo che i suoi dati siano disponibili all'esterno ma che l'utente programmatore utilizzi di volta in volta i metodi offerti dalla classe per operare sull'oggetto.

Questa caratteristica tipica dei linguaggi OO si dice astrazione perché crea tipi di dati astratti (non ci interessa come fisicamente sono memorizzati ne come si debba operare su di essi).

Per incapsulare le variabili nell'oggetto (cioè non renderle disponibili all'esterno) basta utilizzare lo specificatore di accesso private.

Al contrario, generalmente vogliamo che i metodi siano disponibili all'esterno della classe, per questo utilizzeremo lo specificatore di accesso public.

Una classe utilizza un altra

Nell'esempio sopra le due classi possono essere in due file separati. Non c'è bisogno che siano nello stesso, ma andrebbe bene ugualmente. Come regola nel nostro corso li terremo tutti nella stessa directory. Attenzione: solo una classe per file può essere dichiarata public.

Un secondo esempio

class ContoBancario {
  // Variabili istanza:
  private double saldo;

  // Metodi istanza:
  // costruttore predefinito
  public ContoBancario() {
    this.saldo = 0.0;
  }
  // costruttore alternativo
  public ContoBancario(double sommaIniziale) {
    this.saldo = sommaIniziale;
  }

  public double saldoConto() {
    return this.saldo;
  }

  public void deposita(double sommaDepositata) {
    this.saldo += sommaDepositata;
  }

  public void preleva(double sommaPrelevata) {
    this.saldo -= sommaPrelevata;
  }

  // Metodo di classe
  public static void trasferisci(double sommaTrasferita,
    ContoBancario origine, ContoBancario destinatario) {
    origine.saldo -= sommaTrasferita;
    destinatario.saldo += sommaTrasferita;
  }
}

class ProvaConto1 {
  public static void main(String[] args) {
    ContoBancario contoLuigi = new ContoBancario();
    ContoBancario contoGino = new ContoBancario(1000.0);

    // Trasferiamo 100.0 dal conto di Gino a quello di Luigi
    ContoBancario.trasferisci(100.0, contoGino, contoLuigi);

    System.out.println("Saldo di Gino: " + contoGino.saldoConto());
    System.out.println("Saldo di Luigi: " + contoLuigi.saldoConto());
  }
}

Metodi e variabili di classe

Analizziamo il secondo esempio in queste altre slides.

Non sempre un metodo agisce direttamente solo su di un oggetto. Talvolta vengono coinvolti più oggetti, di tipo differente ad esempio. Anche per questo esistono i metodi di classe.

Per definire un metodo di classe va utilizzata la parola chiave static (deriva dal C, ma non ha un significato esplicito).

Inoltre è possibile definire anche delle variabili di classe utilizzando lo specificatore static. Questo vuol dire che ciascun oggetto della classe NON conterrà una copia della variabile, che verrà invece custodita altrove (nello spazio di memoria della JVM chiamato "permanent generation"). Di questa variabile ne esisterà una copia sola.

Le variabili di classe vengono spesso utilizzate per definire dei valori costanti. Per farlo si utilizza lo specificatore final.Esempio:

public static final double PI = 3.14159;

Per convenzione le costanti hanno nomi tutti maiuscoli. Più parole si congiungono con un carattere "_". Esempio:

public static final int ALBERI_MELE = 20;

Metodi e variabili statiche vanno utilizzate il meno possibile!

Un terzo esempio

import javax.swing.*;

class Ellisse {
  // variabili istanza
  private double asseMaggiore, asseMinore;

  // costruttori
  public Ellisse() {
    this.asseMaggiore = 0.0;
    this.asseMinore = 0.0;
  }

  public Ellisse(double maggiore, double minore) {
    this.asseMaggiore = maggiore;
    this.asseMinore = minore;
  }

  // metodi istanza
  public void setAsseMaggiore(double maggiore) {
    this.asseMaggiore = maggiore;
  }

  public void setAsseMinore(double minore) {
    this.asseMinore = minore;
  }

  public double getAsseMaggiore() {
    return this.asseMaggiore;
  }

  public double getAsseMinore() {
    return this.asseMinore;
  }

  public double calcolaArea() {
    return Math.PI * this.asseMaggiore * this.asseMinore;
  }

}

public class AreaEllisse {
  public static void main(String[] args) {
    String stringaInput;
    Ellisse ellisseUtente = new Ellisse();

    stringaInput = JOptionPane.showInputDialog("Inserisci l'asse maggiore: ");
    ellisseUtente.setAsseMaggiore(Double.parseDouble(stringaInput));

    stringaInput = JOptionPane.showInputDialog("Inserisci l'asse minore: ");
    ellisseUtente.setAsseMinore(Double.parseDouble(stringaInput));

    JOptionPane.showMessageDialog(null, "L'area dell'ellisse avente asse minore " +
      ellisseUtente.getAsseMinore() + " e asse maggiore " + ellisseUtente.getAsseMaggiore() +
      " è " + ellisseUtente.calcolaArea() + ".");

    System.exit(0);
  }
}

null

Quando una variabile di tipo riferimento ad oggetto non viene inizializzata:

• (in un metodo) rimane non inizializzata
• (è una variabile istanza) assume il valore null

null è una costante letterale per le variabili di tipo riferimento ad oggetto.

Se abbiamo finito di utilizzare un oggetto, possiamo assegnare al suo riferimento il valore null. il meccanismo di garbage collection della JVM lo eliminerà dallo heap.

Errori comuni

Vediamo alcuni errori in cui è facile incappare lavorando con le classi Java.

Copiare i riferimenti agli oggetti

Abbiamo visto che in Java c'è una differenza sostanziale tra variabili ti tipo riferimento ad oggetto ed oggetti veri e propri. Capiamolo meglio. Consideriamo questa classe:

class Punto3D {
  private double x, y, z;

  public Punto3D(double x0, double y0, double z0) {
    this.x = x0;
    this.y = y0;
    this.z = z0;
  }

  public double getX() {
    return this.x;
  }

  public void setX(double nuovoX) {
    this.x = nuovoX;
  }

  public double getY() {
    return this.y;
  }

  public double getZ() {
    return this.z;
  }

}

A costo di essere noiosi, rivediamo in dettaglio cosa significa istanziare un nuovo oggetto Punto3D

Punto3D questo = new Punto3D(1.0,2.0,1.0);

Ecco uno schema dei quattro passi necessari:

Vediamo invece cosa succede quando dichiariamo una variabile di tipo primitivo:

double distanza = 10.0;

Riassumendo:

• una variabile di tipo riferimento ad oggetto contiene un riferimento;
• una variabile di tipo primitivo contiene un valore.

Attenzione che quando copiate una variabile oggetto viene copiato solo il riferimento all'oggetto (cioè ovviamente il contenuto della variabile). Esempio:

    Punto3D questo = new Punto3D(1.0,2.0,3.0);
    Punto3D quello;

    quello = questo; // attenzione! quello e quello contengono lo stesso riferimento!
    quello.setX(8.0);

    System.out.println(questo.getX()); //Stampa 8.0 non 1.0!

Confrontare i riferimenti agli oggetti

Quando confrontate due variabili di tipo riferimento ad oggetto non confrontate gli oggetti! Esempio:

    Punto3D questo = new Punto3D(1.0,2.0,3.0);
    Punto3D quello = new Punto3D(1.0,2.0,3.0);

    if(questo == quello) { // Attenzione stiamo confrontando i riferimenti NON gli oggetti!
      System.out.println("I due riferimenti coincidono");
    }

    if((questo.getX()==quello.getX()) &&
      (questo.getY()==quello.getY()) &&
      (questo.getZ()==quello.getZ())) { // Giusto
      System.out.println("I due punti coincidono");
    }

Una soluzione più efficace ed elegante è quella di sovrascrivere il metodo equals() della superclasse Object. Lo vedremo in seguito.

Dimenticarsi di chiamare il costruttore

Da quello che abbiamo visto prima se ci dimentichiamo di invocare il costruttore i passi 2, 3 e 4 non vengono effettuati. La variabile oggetto contiene un valore qualunque e il compilatore si lamenta con l'errore variable ... might not have been initialized. Esempi:

    Punto3D questo;
    questo.setX(10.0); // Sbagliato questo non è stata inizializzata

    Punto3D questo = null;
    questo.setX(10.0); // Sbagliato questo non si riferisce a nessun oggetto

    Punto3D quello = new Punto3D(1.0,2.0,3.0);
    quello.setX(20.0); // Giusto

Invocare il costruttore come metodo istanza

    Punto3D quello = new Punto3D(1.0,2.0,3.0);

    // Sbagliato non possiamo ricreare un oggetto!
    quello.Punto3D(6.0,0.0,1.0);

    // Giusto, creiamo un secondo oggetto e ne mettiamo il riferimento in quello.
    // Il vecchio oggetto viene eliminato prima o poi dal meccanismo automatico
    // di garbage collection.
    quello = new Punto3D(6.0,0.0,1.0);

Chiamare un metodo istanza senza specificare su quale oggetto deve operare

    Punto3D quello = new Punto3D(1.0,2.0,3.0);

    setX(10.0); // Sbagliato, su quale oggetto deve operare?

Lab

Anticipazione: visualizzazione di componenti GUI

Cominciamo a vedere alcuni esempi che ci introducano verso la costruzione delle interfacce utente grafiche (GUI). Il primo esempio costruisce una finestra vuota a schermo:

import javax.swing.JFrame;

public class PrimaProvaFrame {
  public static void main(String[] args) {
    JFrame frame1 = new JFrame();

    frame1.setTitle("La mia prima finestra");
    frame1.setSize(300,150);
    frame1.setLocation(200,200);
    frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    // System.exit(0); mi chiude anche il frame ...
    frame1.setVisible(true);
  }
}

Il secondo esempio aggiunge alla finestra alcuni componenti, i mattoni base per la costruzione di una interfaccia.

import javax.swing.*;

public class SecondaProvaFrame {
  public static void main(String[] args) {
    // Per prima cosa costruiamo un pò di componenti
    JLabel etichetta = new JLabel("Testo etichetta");
    JTextField campoTesto = new JTextField("Qui puoi scrivere qualcosa");
    JButton bottone = new JButton("Conferma");
    JCheckBox checkBox = new JCheckBox("Scelta 1");
    JRadioButton radioButton = new JRadioButton("Scelta 2");
    JComboBox comboBox = new JComboBox(new String[] {"Valore 1", "Valore 2", "Valore 3"});
    
    // Inserisce i componenti in un pannello
    JPanel mioPannello = new JPanel();
    mioPannello.add(etichetta);
    mioPannello.add(campoTesto);
    mioPannello.add(bottone);
    mioPannello.add(checkBox);
    mioPannello.add(radioButton);
    mioPannello.add(comboBox);
        
    JFrame frame1 = new JFrame();
    frame1.add(mioPannello);
    frame1.setTitle("La mia prima finestra");
    frame1.setSize(300,150);
    frame1.setLocationRelativeTo(null);
    frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame1.setVisible(true);
  }
}