S.I.S.S.I.S. Catania 2002/03
Amuso Raffaele
LE APPLET
JAVA
Prof. D. Cantone
Prerequisiti:
Conoscenze di base del linguaggio
Java;
Conoscenze delle interfacce grafiche
in Java;
Generalità sulle immagini.
Obiettivi:
Cognitivi:
- Conoscere gli elementi fondamentali di
un’applicazione web oriented;
- Conoscere le possibili interazioni
dell’utente con un’applicazione web;
Operativi:
- Saper passare i parametri ad un
applet;
- Saper costruire un applet con elementi
grafici ed interfacce utente.
Metodologie:
Lezione frontale;
Esercitazioni pratiche;
Piccoli progetti.
Strumenti:
Libro di testo;
Appunti dell’insegnante;
Calcolatore (JDK e IE).
Verifica/Valutazione:
Test V/F;
Test pratico in laboratorio.
Tempi:
3 settimane (totale 18 ore).
Teoria
6 ore
Laboratorio
6 ore
Verifica
3 ore
Approf./Recupero
3 ore
Contenuti:
Introduzione alle Applet;
HTML e Applet;
La classe Applet;
L’appletwiever ed i browser.
Contenuti:
Le classi Canvas e Graphics;
I metodi grafici;
Le immagini e le Applet;
L’awt e le Applet;
I thread e le Applet;
Le Midlet (cenni).
Cosa sono le Applet:
Le Applet sono applicativi web
oriented scritti in linguaggio Java;
Esse possono essere eseguite da un
qualunque web browser compatibile
con java;
Vengono usate soprattutto per
applicazioni grafiche e interattive.
Perché le Applet:
In origine le pagine web erano
spoglie e povere di grafica;
Non era possibile creare degli
applicativi direttamente nelle pagine
web;
Tramite le Applet è stato possibile sia
aumentare la qualità grafica del web
che creare piccoli applicativi
all’interno delle pagine.
Come funzionano:
javac
Bytecode
file.html
Browser con Java W.M.
file.java
Sicurezza:
Le Applet risultano sicure poiché, a
differenza delle applicazioni, esse
hanno alcune importanti restrizioni;
Un applet non può compiere le
seguenti operazioni:
> Leggere e scrivere file locali;
> Aprire una connessione con un server diverso da
quello che la ospita;
> Lanciare altre applicazioni sulla macchina locale;
> Invocare il metodo System.exit();
> Accedere alle proprietà del sistema.
HTML e Applet:
In un file HTML è
possibile richiamare un file in
bytecode (.class) contenente
un’ applet;
Il TAG <APPLET> ci consente di
inserire all’interno della nostra pagina
HTML un’applet java.
HTML e Applet:
I parametri del TAG
<APPLET> sono:
CODE (nome del file .class)
CODEBASE (path della directory di lavoro)
HEIGHT e WIDTH (dimensioni dell’applet)
All’interno del TAG <APPLET> è
inoltre possibile passare i parametri
relativi all’applet.
HTML e Applet:
ESEMPIO:
<HTML>
<BODY>
<APPLET
CODE=“file.class” CODEBASE=“.”>
<PARAM name=p1 value=0>
<PARAM name=p2 value=2>
<PARAM name=p3 value=“pippo”>
</APPLET>
</BODY>
</HTML>
La classe Applet:
Le applet vengono create estendendo
la classe predefinita Applet;
+--java.awt.Panel
| +--java.applet.Applet
Osservando la gerarchia delle classi
si vede che la classe applet è una
sottoclasse della classe Panel e ne
eredita tutte le proprietà
(componenti).
La classe Applet:
Diversamente dalle applicazioni java
non occorre creare un frame, poiché
esso è fornito direttamente dal
browser che esegue l’applet;
Per creare un’applet bisogna
importare il package:
“java.applet.*”
esso infatti rende visibile la classe
Applet all’interno del programma.
La classe Applet:
La struttura generale di un’applet è la
seguente:
import java.applet.*;
public class <nome dell’applet> extends Applet
{
// attributi dell’applet
// metodi dell’applet
}
I metodi delle Applet:
I medoti introdotti dalla classe
applet sono:
Deve essere ridefinito
se l’applet implementa
l’interfaccia “runnable”.
public void init();
public void start();
public void run();
public void stop();
public void destroy();
Essi sono richiamati dal browser o
dall’appletviewer.
I metodi delle Applet:
Schema di funzionamento di
un’applet:
INIT
START
RUN
STOP
DESTROY
I metodi delle Applet:
La struttura di un applet java sarà
quindi la seguente:
import java.applet.*;
public class <nome dell’applet> extends Applet
{
public void init() {
// Inizializzazione
}
public void start() {
// Parte l’applet
}
public void run() {
// Corpo principale dell’applet
}
public void stop() {
// L’applet si ferma
}
public void destroy() {
// L’applet viene chiusa
}
}
Canvas e Graphics:
Il browser nel quale viene lanciata
l’applet crea un frame in automatico.
Ad un frame è possibile aggiungere
pannelli e quindi componenti (bottoni,
menù eccetera).
Nel pannello dell’applet è inserito
automaticamente un oggetto Canvas
Un Canvas è una “tela” dove è
possibile disegnare.
Canvas e Graphics:
Finestra dell’applet
Canvas
( contiene il metodo paint )
Per disegnare nel canvas bisogna
ridefinire il metodo paint.
Dentro il metodo paint è possibile
disegnare tramite i metodi della
classe Graphics.
Canvas e Graphics:
(0,0)
(w-1,h-1)
Per ottenere le dimensioni del canvas
(quindi dell’applet) basta richiamare il
metodo getSize().
Tale metodo torna i seguenti interi:
int w = getSize().width; (torna la larghezza)
int h = getSize().height; (torna l’altezza)
Il metodo paint:
La finestra dell’applet fornita dal
browser è una matrice di pixel wxh,
dove andremo a scrivere tramite il
metodo Paint. Tale metodo viene
richiamato automaticamente.
import java.applet.*;
import java.awt.*;
public class <nome della classe> extends Applet
{
…
…
public void paint(Graphics g)
{
// Ciò che verrà visualizzato nell’applet
// Va inserito qui
}
}
Il metodo paint:
Vi sono numerosi metodi per scrivere
in tale matrice.
Uno dei primi metodi che si usa è
drawString:
Graphics.drawString(String s,int x,int y);
drawString è usato per scrivere del
testo nello schermo dell’applet alle
coordinate (in pixel) specificate.
La prima Applet:
Applet che stampa una
stringa a video:
import java.applet.*;
import java.awt.*;
public class Hello extends Applet
{
int X,Y;
String S;
public void init()
{
S = new String("Ciao a tutti!");
X=20; Y=20;
}
public void paint(Graphics g)
{
g.drawString(S,X,Y);
}
}
La prima Applet:
File HTML che richiama l’applet:
<html>
<applet code="Hello.class" width=320 height=200>
</applet>
</html>
Basta richiamare il file tramite un
browser o con l’appletviewer.
C:>appletviewer Hello.html
La classe Graphics:
I metodi della classe Graphics (da
richiamare dentro paint():
Graphics.setColor(Color c);
Graphics.drawString(String s,int x,int y);
Graphics.fillRect(int x1, int y1, int x2, int y2);
Graphics.fillOval(int cx, int cy, int dx, int dy);
Graphics.drawRect(int x1, int y1, int x2, int y2);
Graphics.drawOval(int cx, int cy, int dx, int dy);
Graphics.drawLine(int x1, int y1, int x2, int y2);
Graphics.drawImage(Image i, int x,int y, null);
Graphics.fillArc(int x, int y, int dx, int dy, int startG, int arcG);
I colori:
La gestione dei colori in java è
affidata alla classe Color.
Esiste una lista di colori predefiniti:
Color.black;
Color.white;
Color.red;
Color.green;
…
Oppure si può istanziare un colore
tramite le sue componenti RGB in
questo modo:
Color rosso = new Color(255,0,0);
Passaggio di parametri:
E’ possibile passare dei parametri
all’applet dal file HTML (tag PARAM)
Ogni parametro ha un nome ed un
valore;
L’applet legge i parametri tramite il
metodo getParameter().
Passaggio di parametri:
Applet che stampa una
stringa passata come paramero:
import java.applet.*;
import java.awt.*;
public class Hello extends Applet
{
int X,Y;
String S;
public void init()
{
S =getParameter("text");
X=20; Y=20;
}
public void paint(Graphics g)
{
g.drawString(S,X,Y);
}
}
Passaggio di parametri:
File HTML che richiama l’applet (con
parametri):
<html>
<applet code="Hello.class" width=320 height=200>
<PARAM name=“text” value=“Ciao a tutti!”>
</applet>
</html>
I parametri vengono letti tutti come
stringhe, bisogna quindi operare le
opportune conversioni nel leggere
parametri numerici.
I thread:
I thread ci consentono di sfruttare le
potenzialità multitasking del S.O.;
Ha senso usare i metodi star(), run()
e stop() solo quando un applet e
implementata come Runnable;
In questo caso l’applet viene vista
come un processo del S.O. che può
avere una priorità, essere fermato,
fatto ripartire o trovarsi nello
stato di run.
I thread:
Per associare una applet ad un
thread dobbiamo istanziare la classe
Thread.
I metodi della classe Thread sono:
setPriority(P);
start();
stop();
sleep(M);
(P può essere: MAX_ PRIORITY, MIN_ PRIORITY, NORM_ PRIORITY)
(M rappresenta i Millisecondi di sleep)
Semplice scrolling:
Esempio dell’uso dei thread.
import java.applet.*;
import java.awt.*;
public class Hello extends Applet implements Runnable {
int X,Y; String S;
Thread RUN;
public void init() {
public void paint(Graphics g) {
S = new String("Ciao a tutti!");
g.setColor(Color.white);
X=20; Y=20; }
g.fillRect(0,0,320,200);
public void start() {
g.setColor(Color.black);
RUN=new Thread(this);
g.drawString(S,X,Y); }
RUN.setPriority(RUN.MIN_PRIORITY);
}
RUN.start();
}
public void run() {
while(true) {
X++; if(X>320) X=-20;
paint(getGraphics()); // Manda a video
try{ RUN.sleep(10); } catch(Exception e) {} } }
public void stop() { RUN.stop(); }
Le immagini:
La gestione delle immagini è compito
della classe Image.
Un’immagine dovrà essere contenuta
in una variabile di tipo Image.
Caricamento di un immagine
da un file:
Image SFONDO;
…
SFONDO=getImage(getDocumentBase(),getParameter("img"));
…
Carica
l’immagine
Directory di
lavoro
dell’applet
Prende il
valore del
parametro
Le immagini:
Il file HTML si presenta cosi:
<html>
<applet
codebase=“.” code="Hello.class“
width=320 height=200>
<PARAM name=“img” value=“papero.gif”>
</applet>
</html>
Nome del
parametro
Valore
(nome
del file)
Sarà possibile stampare l’immagine
a video tramite il metodo drawImage().
Esempi finali:
Scroll di testo con sfondo;
Esempio di A.W.T.;
Effetto grafico natalizio.
Le midlet (cenni):
javac
file.java
Bytecode
Cellulare con Java W.M.
Si usa Java Micro Edition e il wireless toolkit.
java.sun.com
Le midlet (cenni):
La “filosofia” delle midlet è simile a
quella delle applet. Una midlet è
costruita come estensione della
classe MIDlet:
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class <nome midlet> extends MIDlet
{
// attributi della midlet
Metodi per il
// metodi della midlet
display LCD
}
Fine!
