Oggi abbiamo visto come, con Java, si possono realizzare applicazioni fruibili online, sfruttando semplicemente le pagine HTML per visualizzare la nostra applicazione, senza che l’utente debba installare o eseguire nient’altro che il proprio browser.
Le Applet sono strumenti che, per certi versi, possono semplificare la vita a chi vuole rendere disponibile il proprio programma ad una vasta gamma di utenti, senza per forza far scaricare il sorgente e farlo eseguire.
Questo porta a inevitabili conseguenze, come la pesantezza dell’applicazione e della pagina HTML. Il controllo da parte del programmatore sulla presenza di Java Virtual Machine installare sul computer dell’utente. L’impossibilità, a meno di certificazioni da accettare, di manipolare eventuali file di qualunque genere.
Sono tutti problemi che, inizialmente, possono sembrare di poco conto, ma che alla lunga rendono la programmazione delle Applet un’arte quasi sopraffina.

A lezione abbiamo visto come sono costruite le Applet e le loro dirette sottoclassi, le JApplet.
Molto simili ai JFrame, come struttura interna, non sono però disposte di metodi che ne definiscono la visiblità, le dimensioni o il posizionamento relativo rispetto a qualche punto dello schermo. Questi sono tutti compiti che devono essere svolti dal programmatore della pagina HTML, definendo delle opzioni di stile per il tag <applet&rt;.

Il codice quindi della classe che estende JApplet abbiamo visto essere molto elementare:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/*
Classe JApplet
*/
public class JAVA_20090525 extends JApplet
{
	/*
	Metodo "inizializzatore" delle Applet
	*/
	public void init()
	{
		//Aggiunta del Pannello al contentPane dell'Applet
		getContentPane().add(new Pannello());
	}
}

Quando si costruisce un Applet, non occorre definire il codice del metodo main. Questo metodo infatti serve solamente per lanciare le applicazioni eseguite localmente.
Per le Applet il metodo che è stato predisposto per l’inizializzazione delle varie variabili è il metodo init.
Questo metodo funge anche da “pseudo-costruttore” per l’Applet stessa.

Nel mio caso, ho inserito, nel metodo init, il codice per l’inserimento di un oggetto di tipo Pannello all’interno del ContentPane del JApplet.

La classe Pannello è sostanzialmente un JPanel, con delle opzioni di disegno e gestione degli eventi del mouse al suo interno:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

/*
Definizione della classe Pannello
*/
class Pannello extends JPanel
{	
	//ArrayList contenente l'insieme dei punti che definiranno il disegno della linea
	ArrayList linea = null;
 
	public Pannello()
	{
		eventHandler();
	}
 
	/*
	Metodo contenente l'implementazione degli ascoltatori del mouse statici e dinamici
	*/
	public void eventHandler()
	{
		addMouseListener(new MouseAdapter()
		{
			public void mousePressed(MouseEvent e)
			{
				linea = new ArrayList();
				linea.add(new Punto(e.getX()-getWidth()/2, e.getY()));
			}
 
			public void mouseReleased(MouseEvent e)
			{
				linea.add(new Punto(e.getX()-getWidth()/2, e.getY()));
			}
		});
 
		addMouseMotionListener(new MouseMotionAdapter()
		{
			public void mouseDragged(MouseEvent e)
			{
				if (linea != null)
					linea.add(new Punto(e.getX()-getWidth()/2, e.getY()));
				repaint();
			}
		});
	}
 
	/*
	Ridefinizione del Paint per il disegno della linea con l'effetto di rotazione
	applicato intorno all'asse centrale del pannello
	*/
	public void paint(Graphics _g)
	{
		Graphics2D g = (Graphics2D)_g;
		super.paintComponent(g);
		g.setColor(Color.WHITE);
		g.fillRect(0, 0, getWidth(), getHeight());
 
		g.setColor(Color.BLACK);
 
		if (linea != null && linea.size() > 1)
    		for (int i=1; i<linea.size(); i++)
    		{
    			Punto p1 = (Punto)linea.get(i-1);
    			Punto p2 = (Punto)linea.get(i);
 
    			p2.updateTheta();
    			g.draw(new Line2D.Double( p1.getX(getWidth()/2), p1.getY(), p2.getX(getWidth()/2), p2.getY() ));
    			p1.updateTheta();	
    		}
	}
}

La classe Pannello, per poter disegnare la figura (che all’esecuzione dell’applet si vedrà più chiaramente), sfrutta oggetti di tipo Punto.
Questi oggetti sono stati descritti dalla classe Punto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/*
Classe per la descrizione del singolo punto che sarà alla base
del tracciato segnato dal mouse.
*/
class Punto
{
	//Coordinate X e Y del punto
	double x, y;
 
	//Angolo di rotazione
	double theta;
 
	public Punto(double x, double y)
	{
		this.x = x;
		this.y = y;
	}
 
	/*
	Metodo che provvede all'aggiornamento dell'angolo di rotazione incrementando
	ogni volta il valore dell'angolo di PI/200 radianti
	*/
	public void updateTheta()
	{
		theta += Math.PI / 200;
	}
 
	/*
	Metodo che ritorna la posizione della coordinata X del punto, traslata
	del valore passato al metodo e "ruotato" del valore dell'angolo del punto
	*/
	public double getX(double translatex)
	{
		return translatex + x * Math.cos(theta);
	}
 
	/*
	Metodo che ritorna la posizione della coordinata Y del punto.
	*/
	public double getY()
	{
		return y;
	}
}

Ora, per poter dire alla pagina HTML che vogliamo eseguire l’applet, occore scrivere un codice simile a questo:

<html>
	<!-- CORPO della pagina HTML -->
	<body>
		<!-- TAG "applet" per l'inserimento dell'applet nella pagina -->
		<applet
			code="JAVA_20090525.class"
			width="200"
			height="200">
		</applet>
		<!--
			Il tag Applet prevede una costruzione di base di questo tipo:
 
			<applet
 
			Indirizzo del file .class contente il JApplet con il metodo init
			code="indirizzo_file_class.class" 
 
			Larghezza e altezza dell'applet all'interno della pagina HTML
			width="larghezza_in_px"
			height="altezza_in_px">
		-->
	</body>
</html>

Per poter eseguire l’applet da riga di comando, invece che dal browser, si possono sfruttare alcuni comandi nativi di Java.
Può essere utile sfruttare questi metodi per evitare di dover, ogni volta, cancellare la cache del browser per evitare problemi di visualizzazione.

appletviewer -classic index.html

Dove, con “index.html” ci si riferisce alla pagina HTML che contiene il codice di embedding dell’applet.

Ovviamente, per debug veri e propri, è consigliabile eseguire l’applet sia sul proprio browser, quindi in locale, sia caricando la pagina su qualche server online ed accedendo all’Applet mediante quel server, per verificare la completa funzionalità dell’applicazione per tutte le utenze.

Questa pagina è un esempio: JRotatingLines
Per vedere l’applet in funzione cliccate e trascinate il mouse all’interno del rettangolo bianco.

GD Star Rating
loading...