Capitolo 3 - La programmazione OO

I linguaggi di programmazione hanno come scopo principale quello di aiutare a "tradurre" le entità del mondo reale e i loro comportamenti in strutture informatiche quali variabili, liste, funzioni, puntatori, "struct", ecc. La programmazione a oggetti, OOP, rende molto più naturale creare questa "mappa", permettendo di manipolare oggetti che assomigliano molto alla loro controparte del dominio che si vuole rappresentare.

Classi

Una classe è praticamente un tipo di dato, paragonabile (alla lontana) alle struct del C. Una istanza (variabile) di una classe è un oggetto.

Una classe adatta a rappresentare una persona potrebbe essere definita così:

	class Persona
	{
		String nome,
			cognome,
5			indirizzo;
		int nCivico;

		Persona(String nome,
				String cognome,
10				String indirizzo,
				int nCivico)
		{
			this.nome = nome;
			this.cognome = cognome;
15			this.indirizzo = indirizzo;
			this.nCivico = nCivico;
		}
	}

Dalla linea 3 si possono vedere dei campi di tipo String e uno di tipo intero.

In linea 8 si vede in azione il costruttore. Il costruttore ha lo stesso nome della classe e si occupa di inizializzare l'oggetto - viene chiamato quando si alloca memoria con new.
Se non si definisce il costruttore per una classe, Java ne fornisce uno predefinito, senza argomenti.

La parola chiave this è semplicemente un riferimento all'oggetto corrente; in questo caso viene usato per distinguere i campi dell'oggetto dai parametri passati al costruttore, per i quali ho voluto usare gli stessi nomi.

Operare sugli oggetti

Un programma java inizia la sua esecuzione dal metodo main di una classe. Tutte le classi, ad esclusione delle classi annidate, possono avere un main; ciò è utile per testare la classe durante lo sviluppo, anche se allo scopo esistono strumenti più sofisticati, come JUnit.

In questo caso possiamo inserirlo nella definizione di Persona o in un'altra classe a cui sia visibile:

	public static void main(String[] args)
	{
		Persona p = new Persona("Mario",
				"Rossi",
5				"via Di Qua",
				5);
	
		System.out.println("Il mio nome e' " + p.nome);
	}

In linea 3 viene allocata sullo stack la variabile p - un riferimento a Persona - alla quale viene subito assegnato un oggetto, creato sullo heap.

In linea 8 si accede direttamente al campo nome di p; in generale questa non è una buona cosa - ad esempio si può volere che una volta creato un oggetto Persona i suoi campi non siano modificabili, mentre con la classe definita sopra nulla vieta di scrivere qualcosa come:

	p.nome = "Carlo";

In questo caso particolare la cosa può risultare abbastanza innocua, ma quando si ha a che fare con un programma di una certa dimensione è meglio non andare a toccare direttamente la struttura interna di un oggetto. C'è quindi bisogno di un meccanismo per controllare l'accesso a campi e metodi.

Nascondere l'implementazione

Modifichiamo leggermente la classe precedente:

	class Persona
	{
		private String nome,
			cognome,
			indirizzo;
		private int nCivico;

		public Persona(...

Il costruttore invece decidiamo di renderlo pubblico - non è obbligatorio - in modo da permettere a tutti di creare oggetti di tipo Persona.

Un costruttore privato ha senso per esempio se si vuole controllare il numero di oggetti creati; allo scopo si userà un metodo statico:

	private static int numero = 0;

	private Persona(...
	...

	/** Crea al massimo 10 persone */
	public static Persona creaPersona(String nome, ...)
	{
		if(numero == 10)
			throw new TroppePersoneException();
	
		numero++;
		return new Persona(nome, ...);
	}

	Persona pino = Persona.creaPersona("Pino", ...);

Interfacce

Il senso del discorso precedente è che è opportuno esporre meno codice possibile.
Ciò che conta non è l'implementazione, ma l'interfaccia di una classe, e infatti in java esistono le interfacce.

Ad esempio si supponga di voler definire il comportamento di una pila di numeri senza specificarne l'implementazione.
Una pila deve permettere come minimo due operazioni, push e pop; questo fatto si può descrivere così:

	interface PilaDiNumeri
	{
		public void push(int n);
		public int pop();
	}

	class P implements PilaDiNumeri
	{
		/* codice... */
	
		public P()
		{
			/* codice... */
		}

		public void push(int n)
		{
			/* codice... */
		}
	
		public int pop()
		{
			/* codice... */
		}

		/** Ritorna l'elemento in cima
		 * alla pila, senza rimuoverlo.
		 */
		public int top()
		{
			/* codice... */
		}
	}

Inoltre una classe può implementare più interfacce:

	class P
	    implements PilaDiNumeri, Iterable

Campi e metodi statici

Quando un campo o un metodo è dichiarato static "fa parte" della classe, e non di un oggetto in particolare.

Come esempio si consideri il precedente metodo creaPersona; non è possibile chiamarlo riferito a un oggetto, così:

	/* NO!
	Persona alfio = gianni.creaPersona(... */

	/* si' */
	Persona alfio = Persona.creaPersona("Alfio", ...

	java Persona

Costanti ed enumerazioni

Quando una variabile è final non può essere modificata:

	final float PI = 3.14f;

	/* NO!
	PI = 5; */

	/** Specifica le possibili modalita'
	 * di scrittura di un file.
	 */
	class Mode
	{
		public final Mode
			RO = new Mode(),	// read only
			RW = new Mode(),	// read - write
			WO = new Mode();	// write only

		private Mode() {}
	}

Questo era necessario fino a java 1.5, che ha introdotto le enum; la singola linea:

	enum Mode { RO, RW, WO }

Classi annidate

Una classe può essere definita all'interno di un'altra classe o di un metodo:

	class FileDiTesto
	{
		...
	
		class LineSeparator
		{
			...

Una inner class può essere anonima, nel caso ci sia bisogno di una classe "usa e getta"; come esempio il metodo seguente, definito dall'interfaccia Iterable, ritorna un Iterator, creato "al volo":

	Iterator iterator()
	{
		return new Iterator()
			{
				boolean hasNext()
				{ ... }

				Object next()
				{ ... }

				void remove()
				{ ... }
			}
	}

Il classpath

Quando si chiede all'interprete java di eseguire una classe, ad esempio con

	java Persona

	.:main.jar:/usr/local/javaclasses

	java -cp . Persona

I file jar

Vi sarete accorti che il compilatore java produce un file .class per ogni classe che trova nel sorgente, il che può essere scomodo, soprattutto nel caso in cui il vostro programma debba essere distribuito, o scaricato come applet.

Per ovviare al problema nel JDK è incluso il tool jar, che consente di archiviare in un singolo file tutti i .class - e tutti i file di supporto come immagini, suoni, ecc. - relativi a un programma.

Prima di tutto è necessario creare un file di testo, detto manifest, per indicare a jar, tra l'altro, quale è la classe principale che deve essere eseguita; nel caso di prima il file - supponiamo di chiamarlo "mf" - dovrà contenere la riga:

	Main-Class: Persona

	jar cvf p.jar -m mf Persona.class

	java -jar p.jar

I package

Le classi java possono essere organizzate gerarchicamente in package. Ad esempio supponiamo che in una directory inclusa nel classpath - e che quindi sia visibile a java - ci sia un'altra directory lib, in cui è contenuto il seguente file Ciao.java:

	package lib;

	public class Ciao
	{
		public static void ciao()
		{
			System.out.println("ciao ciao");
		}
	}

Dopo aver compilato il file possiamo usare la classe Ciao da qualsiasi programma, direttamente con:

	lib.Ciao.ciao();

	import lib.Ciao;
	
		...
		Ciao.Ciao();
		...

	import java.util.*;	// importa tutte le classi del package java.util

Prima abbiamo visto come controllare l'accesso ai membri di una classe tramite public e private. Se non si usano queste keyword, ad esempio:

	int max(...) { ... }

Se in un file sorgente non viene dichiarato il package le classi contenute in quel file apparterranno al package di default, ossia al package di cui fanno parte le classi presenti nella stessa directory - a meno che queste non abbiano dichiarato di appartenere ad un altro package.