Java_D_back end.indd - Mondadori Education

annuncio pubblicitario

I dati strutturati
back end..;-)
eSerCIZI SVOltI
CreaZIOne dI Un’aPPlet (UnItà d1)
1
Crea un’applet che scriva nella sua finestra una frase passata come parametro da htMl, impostando
un font specifico e scrivendo ogni carattere di un colore diverso.
•c
•c
•c
•c
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Font;
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
•c
public class ScriviNomeAColori extends java.applet.Applet
{
private String frase = "Ciao ";
private java.awt.Color colori[];
Font mioFont;
public void init()
{
colori=new java.awt.Color[3];
colori[0]=java.awt.Color.cyan;
colori[1]=java.awt.Color.magenta;
colori[2]=java.awt.Color.green;
String st_temp = getParameter("tuoNOME”);
if(st_temp == null)
frase += ", sconosciuto !”;
else
frase += st_temp + " !”;
}
public void paint(Graphics g)
{
String temp;
int l,i,k;
l=frase.length();
mioFont = new Font("Monospaced”,Font.BOLD,30);
g.setFont(mioFont);
for(i=0;i<l;i++)
{
k=i%3;
g.setColor(colori[k]);
temp=frase.substring(i,i+1);
c
D back end..;)
1
•c g.drawString(temp,20+25*i,60); //distanzio i caratteri
•c }
}
•c }/* fine classe*/
•c
Il documento HTML che contiene l’applet sarà:
<HTML>
<HEAD>
<TITLE>
Applet che visualizza singoli caratteri in vari colori
<TITLE>
</HEAD>
<BODY>
<OBJECT code=”ScriviNomeAColori.class” width=600 height=120>
<param name =”tuoNOME”” value = “Amico Fritz”>
</OBJECT>
</BODY>
</HTML>
La classe Font offre molte opportunità di modificare i font già disponibili (spessore, dimensione, …)
nonché di crearne di nuovi. Ti invitiamo a consultare la documentazione ufficiale e a fare qualche prova.
I thread (Unità D2)
2 Due pallini in due thread diversi si muovono in due finestre differenti.
•c import
java.awt.Graphics;
•c import java.awt.Color;
•c import java.awt.Event;
•c import java.awt.*;
•c import javax.swing.*;
•c
•c public
class ThreadApp2
•c {
public static void main(String args[])
{
•c JFrame f1 = new JFrame("Disegno");
•c JFrame f2 = new JFrame("Disegno");
•c f1.setSize(300,200);
•c f1.setLocation(1,1);
•c f2.setSize(300,200);
•c f2.setLocation(300,1);
•c
•c
c
D back end..;)
2
•c TPallino t1 = new TPallino(Color.red,120);
•c TPallino t2 = new TPallino(Color.blue,60);
•c f1.getContentPane().add(t1);
•c f1.setVisible(true);
•c f2.getContentPane().add(t2);
•c f2.setVisible(true);
•c Thread runner1= new Thread(t1); //il thread runner1 contiene l’oggetto t1
•c Thread runner2= new Thread(t2); //runner2 contiene l’oggetto t2
•c runner1.start();
•c try
•c {Thread.sleep(2000); } /* introduco due secondi di ritardo */
•c catch (InterruptedException e) { }
•c runner2.start();
•c
}
•c }
•c
•c class
TPallino extends JComponent implements Runnable //classe nello stesso file, non public
•c {
•c
int xpos;
•c
int raggio;
•c
Color colore;
•c
•c
public TPallino(Color c, int r)
•c
{
•c xpos=0;
•c raggio=r;
•c colore=c;
•c
}
•c
public void run()
•c
{
•c while (true)
•c {
•c for (xpos = 5; xpos <= 105; xpos+=raggio/10)
•c {
•c repaint();
•c try { Thread.sleep(100); }
•c catch (InterruptedException e) { }
•c }
•c for (xpos = 105; xpos > 5; xpos -=raggio/10)
•c {
•c repaint();
•c try { Thread.sleep(100); }
•c •c catch (InterruptedException e) { }
}
•c }
•c
}
•c
public void paint(Graphics g)
•c
{
c
D back end..;)
3
•c g.setColor(colore);
•c g.fillOval(xpos,5,raggio/2,raggio/2);
•c }
•c } // fine classe ThreadPallino
Come puoi notare, abbiamo due flussi di esecuzione (nell’ambito del processo principale) completamente
indipendenti: il primo pallino corre indipendentemente dal secondo (generato dopo due secondi).
Per creare 100 flussi di esecuzione separati avremo potremmo scrivere, al momento della creazione e
avvio dei thread (nel main()):
•c
•c
•c
•c
Thread[] runner = new Array[100]; /* runner è un array di Thread */
int i=0;
while(i<100)
{
Thread.runner[i] = new Thread(new TPallino());
runner[i].start();
•c •c •c
}
Nota anche che abbiamo usato una forma abbreviata (la solita classe anonima!) per creare i thread poiché
non occorre comunicare direttamente con i singoli oggetti Thread.
3 Scrivere sul monitor con i Thread (primo modo).
Costruiamo la seguente classe Java:
•c public
class ScriviFrase extends Thread
•c {
private String frase;
public ScriviFrase(String str)
•c {
•c frase=str;
•c }
•c public void run()
•c {
•c for (int i = 0; i < 10; i++)
•c {
•c System.out.println(i + " " +frase);
•c try
•c {
•c sleep((long)(Math.random() * 1000));
•c }
•c catch (InterruptedException e) {}
•c }
•c System.out.println("Fine Thread " + frase);
•c }
•c }
•c
•c
Questo Thread ScriviFrase scrive sul monitor con tempi casuali la frase ricevuta come parametro.
Nota che abbiamo scritto il Thread ScriviFrase come classe che estende la classe Thread.
Creamo ora una classe che istanzia anonimamente 3 volte la classe ScriviFrase creando di fatto tre threads
che vengono eseguiti parallelamente.
•c public
class TestScriviFrase
•c {
•c
public TestScriviFrase() { }
c
D back end..;)
4
public static void main (String[] args)
•c {
•c ScriviFrase s1,s2,s3;
•c
•c s1=new ScriviFrase("Pippo");
s2=new ScriviFrase("Pluto");
s3=new ScriviFrase("Paperino");
s1.start();
s2.start();
s3.start();
•c •c •c •c •c •c
}
•c }
Otterremo come risultato:
La classe precedente poteva anche essere scritta in modo da istanziare anonimamente tre volte la classe
ScriviFrase:
•c public
class TestScriviFrase
•c {
•c
•c
•c
public TestScriviFrase() { }
public static void main (String[] args)
{
new ScriviFrase("Pippo").start(); //prima istanza anonima di ScriviFrase
new ScriviFrase("Pluto").start();
•c new ScriviFrase("Paperino").start();
•c }
•c }
•c •c 4 Scrivere sul monitor con i Thread (secondo modo).
Riscriviamo il Thread ScriviFrase dell’esempio precedente in un altro modo (ottenendo comunque lo stesso
risultato dell’esempio precedente): come classe che implementa Runnable.
•c public
class ScriviFraseRunnable implements Runnable
•c {
c
D back end..;)
5
private String frase;
•c public ScriviFraseRunnable(String str)
•c {
•c frase=str;
•c }
•c
•c
•c
public void run()
{
for (int i = 0; i < 10; i++)
{
•c System.out.println(i + " " + frase);
•c •c try
{
•c Thread.sleep((long)(Math.random() * 1000)); //sleep è un metodo statico della classe
Thread
•c }
•c •c •c catch (InterruptedException e) {}
•c }
System.out.println("Fine Runnable " + frase);
•c } /*fine run()*/
•c } /*fine classe*/
•c La classe di test potrebbe essere:
•c public
class TestScriviFraseRunnable
•c {
public TestScriviFraseRunnable() { }
•c public static void main (String[] args)
•c {
•c ScriviFraseRunnable s1,s2,s3;
•c
•c s1=new ScriviFraseRunnable("Pippo");
s2=new ScriviFraseRunnable("Pluto");
•c s3=new ScriviFraseRunnable("Paperino");
•c Thread ts1=new Thread(s1);
•c Thread ts2=new Thread(s2);
•c Thread ts3=new Thread(s3);
•c ts1.start();
•c ts2.start();
•c ts3.start();
•c }/*fine main()*/
•c }/*fine classe*/
•c I flussi (Unità D3)
5 Rendere persistenti oggetti di classe Punto.
Modifichiamo la classe Punto implementando l’interfaccia Serializable. Chiameremo la nuova classe
PuntoS.
•c import
java.io.*;
•c class PuntoS implements Serializable
•c {
•c int X;
c
D back end..;)
6
int Y;
•c public PuntoS()
•c {
•c X=0;
•c Y=0;
•c }
•c public PuntoS(int x1)
•c {
•c X=x1;
•c Y=0;
•c }
•c public PuntoS(int a, int b)
•c {
•c X=a;
•c Y=b;
•c }
•c public double Distanza(PuntoS P)
•c {
•c return(
Math.sqrt( Math.pow((X – P.X), 2)+ Math.pow((Y – P.Y),2) ) );
•c }
•c } /*Classe PuntoS*/
•c
Scriviamo ora un’applicazione che permetta di rendere persistente un oggetto di classe PuntoS.
•c import
java.io.*;
•c
•c public
class TestPuntoSOut
•c {
public static void main(String [] args)
{
•c try
•c {
•c ObjectOutputStream OUT = new ObjectOutputStream(new FileOutputStream("punti.dat"));
•c PuntoS P = new PuntoS(22,43);
•c OUT.writeObject(P);
•c }
•c catch(IOException e)
•c {
•c System.out.println("si è verificata una eccezione");
•c }
•c }
•c } /*Classe*/
•c
•c
Per concludere, scriviamo un’applicazione che legga dal file precedente l’oggetto memorizzato.
•c import
•c public
java.io.*;
class TestPuntoSIn
•c {
•c
•c
public static void main(String [] args)
{
c
D back end..;)
7
•c try
•c {
•c ObjectInputStream IN = new ObjectInputStream(new FileInputStream("punti.dat"));
•c PuntoS P = (PuntoS) IN.readObject();
•c System.out.println("x: " + P.X + " y: " + P.Y);
•c }
•c catch(Exception e)
•c {
•c System.out.println("si è verificata una eccezione");
•c }
•c } /*fine main()*/
•c } /*Classe*/
6 Rendere persistente un array di punti.
Per rendere persistente un array di punti, è necessario che ogni suo elemento sia un oggetto di classe
PuntoS definita nell’esempio precedente.
Definiamo la classe TestPuntiSOut per la scrittura sul file dell’array:
•c import
java.io.*;
•c
•c public
class TestPuntiSOut
•c {
public static void main(String [] args)
•c {
•c PuntoS[] AP = new PuntoS[10];
•c try
•c {
•c ObjectOutputStream OUT = new ObjectOutputStream(new FileOutputStream("arraypunti.
dat"));
•c for(int i=0; i< AP.length; i++)
•c
AP[i] = new PuntoS((int) (Math.random()*50), (int) (Math.random()*50));
•c OUT.writeObject(AP);
•c }
•c catch(IOException e)
•c {
•c System.out.println("si è verificata una eccezione");
•c }
•c } /* fine main()*/
•c } /*fine Classe*/
•c
Definiamo ora la classe TestPuntiSInt per la lettura dell’array dal file.
•c import
•c public
java.io.*;
class TestPuntiSIn
•c {
public static void main(String [] args)
{
•c PuntoS[] AP;
•c try
•c {
•c
•c
c
D back end..;)
8
•c ObjectInputStream IN = new ObjectInputStream(new FileInputStream("arraypunti.dat"));
•c AP = (PuntoS[]) IN.readObject();
•c for(int i=0; i< AP.length; i++)
•c System.out.println("elemento: " + i + "(" + AP[i].X + "," + AP[i].Y + ")");
•c }
•c catch(Exception e)
•c {
•c System.out.println("si è verificata una eccezione");
•c }
•c }/* fine main()*/
•c } /* fine Classe*/
7 Applet “automobile”, con grafica, GUI, eventi e thread.
Scriviamo un’applet che disegna una semplicissima automobile e un ancor più semplice pannello di controllo dell’auto (cruscotto) e crea inoltre un thread per controllare l’attività delle frecce dal pannello di
controllo.
Il modello proposto è infinitamente migliorabile. Si potrebbero aggiungere thread per ognuno dei possibili controlli del cruscotto: un thread, per esempio, che simuli l’accensione delle luci di posizione o del
riscaldamento e così via.
In questa versione, si controllano soltanto le frecce (essendo l’auto disegnata di profilo, si vede solo la
freccia sinistra). Premendo una volta sul bottone Freccia SX, si provoca l’accensione della freccia sinistra,
premendo due volte la si spenge. Naturalmente, accendere la freccia destra fa spegnere la freccia sinistra.
•c import
java.awt.*;
•c import java.awt.event.*;
•c import java.applet.*;
•c
•c public
class NuovaAuto extends Applet
•c {
Frame F1;
•c Auto A;
•c Thread runner;
•c public boolean FSX= false; // la freccia sinistra è spenta
•c public void init()
•c {
•c // crea i componennti GUI
•c Frame F = new Frame("Cruscotto");
•c CheckboxGroup luci = new CheckboxGroup();
•c Button FrecciaSX = new Button("Freccia SX");
•c Button FrecciaDX = new Button("Freccia DX");
•c •c F.setSize(300,200);
•c F.setLocation(100,100);
•c F.setLayout(new GridLayout(3,4,10,10));
si crea una sola classe di ascolto:
•c puoi aggiungere altri ascoltatori
•c // crea un oggetto della classe d’ascolto
•c GestiscePulsante a1 = new GestiscePulsante();
•c FrecciaSX.addActionListener(a1);
•c FrecciaDX.addActionListener(a1);
•c •c // aggiunge i componenti GUI al Frame F
•c
D back end..;)
c
9
•c F.add(FrecciaSX);
•c F.add(FrecciaDX);
•c F.add(new Label(""));
•c /*
inserisce alcuni oggetti invisibili (label senza testo) per riempire un riquadro del layout e
andare a capo */
•c F.add(new Label(""));
•c F.add(new Label("Luci"));
•c F.add(new Label(""));
•c F.add(new Checkbox("posizione", false, luci));
•c F.add(new Checkbox("anabbaglianti", false, luci));
•c F.add(new Checkbox("abbaglianti", false, luci));
queste caselle di spunta per il
momento non hanno effetto sul
disegno: sta a te far apparire
risposte adeguate ...
•c •c F.setVisible(true);
•c •c // crea il canvas dove viene disegnata l’auto
•c F1= new Frame("Disegna Auto");
•c A = new Auto();
•c runner = new Thread(A);
•c F1.add(A);
•c •c // crea un nuovo thread per l’oggetto Auto
•c runner = new Thread(A);
•c runner.start();
•c •c F1.setSize(600,500);
•c F1.setLocation(250,100);
•c F1.setVisible(true);
•c •c
}
•c
•c
/* definizione della classe ascoltatore interna: ascolta solo i bottoni freccia */
•c
private class GestiscePulsante implements ActionListener
•c
{
•c public void actionPerformed(ActionEvent e)
•c {
•c String bottone = e.getActionCommand();
•c if (bottone.equals("Freccia DX"))
•c {
•c FSX=false;
•c A.repaint();
•c }
•c else if (bottone.equals("Freccia SX"))
•c {
•c •c •c •c
FSX=!FSX;
}
}
}/* fine classe interna GestisciPulsante */
c
•c
D back end..;)
10
•c
//definizione classe interna Auto
•c
public class Auto extends Canvas implements Runnable
•c
{
•c public boolean FSXlamp = false; // implementa la luce lampeggiante
•c public void run()
•c {
•c while (true)
•c {
•c repaint();
•c try { Thread.sleep(800); }
•c catch (InterruptedException e) { }
•c }
•c }
•c public void paint(Graphics g)
•c {
•c Font F = new Font("TimesRoman", Font.BOLD, 20);
•c g.setFont(F);
•c g.fillOval(120,220,60,60);
•c g.fillOval(320,220,60,60);
•c g.setColor(Color.blue);
•c g.drawRect(50,150,400,70);
•c g.drawLine(170,150,200,100);
•c g.drawLine(330,150,300,100);
•c g.drawLine(300,100,200,100);
•c g.setColor(Color.yellow);
•c g.fillRect(50,170,20,30);
•c g.setColor(Color.black);
•c g.fillRect(90,170,20,20);
•c g.setColor(Color.red);
•c g.fillRect(430,150,20,20);
•c g.drawString("JavaCar", 200, 350);
•c g.setColor(Color.white);
•c g.fillRect(90,170,20,20);
•c if (FSX&&FSXlamp)
•c {
•c g.setColor(Color.yellow);
•c g.fillRect(90,170,20,20);
•c }
•c else
•c {
•c g.setColor(Color.white);
•c g.fillRect(90,170,20,20);
•c }
•c FSXlamp = !FSXlamp;
•c }
•c }/* fine Auto */
•c
•c }
/* fine classe NuovaAuto */
D back end..;)
11
Per provare il nostro esempio abbiamo bisogno di un documento HTML che contenga l’applet:
<HTML>
<HEAD>
<TITLE>
Applet che visualizza immagini
</TITLE>
</HEAD>
<BODY>
<APPLET code=”NuovaAuto.class” width=200 height=100> </APPLET>
<BR>
</BODY>
</HTML>
Quindi eseguiamo l’applet con l’appletViewer:
Si aprono le tre finestre seguenti:
D back end..;)
12
eSerCIZI rIePIlOGatIVI
8
Progettare un’applicazione con interfaccia grafica che permetta di acquisire i dati degli iscritti a una
gita, salvare i dati su file e visualizzarli ogni volta che lo si desidera in un’area di testo.
9
Progettare un’applicazione con interfaccia grafica che permetta di memorizzare nomi, numeri di
telefono (fisso e cellulare) e indirizzi e che permetta di effettuare ricerche e di stampare i dati
raccolti.
10
Progettare un’applicazione che disegni sul monitor un labirinto e un “topo”, che possa essere guidato manualmente sui percorsi possibili.
(Suggerimento: si possono usare matrici bidimensionali per descrivere i labirinti; per esempio: “1” può
significare “muro” e “0” “libero”; altri valori possono indicare, ad esempio, la presenza di un altro “topo”,
magari guidato dal programma in percorsi predefiniti o casuali. Non è necessario un disegno particolarmente complesso per rappresentare il “topo”: una “pallina con un po’ di coda” può essere sufficiente.)
Progettare un’applicazione che disegni sul monitor un labirinto e crei alcune istanze di “topi” che
cerchino di raggiungerne l’uscita.
Organizzare poi una “gara” e memorizzare tempi e percorsi di ciascun topo, assegnando a ciascuno
lInK un nome diverso, in modo da creare una “graduatoria”.
Approfondimento: (Suggerimento: per svolgere l’esercizio, è necessario utilizzare i thread e una struttura dinamica (una pila,
Unità B3 come minimo), per evitare di percorrere di nuovo vie risultate senza uscita.)
11
D back end..;)
13