Gestione eventi mouse



Scaricare 154 Kb.
10.12.2017
Dimensione del file154 Kb.

PARADIGMI DI PROGRAMMAZIONE

Nell’ambito della programmazione, con il termine paradigma si intende l’insieme di idee a cui ci si ispira per modellare e per risolvere i problemi .

I principali paradigmi di programmazione sono:

·Imperativo

·Orientato agli oggetti

·Logico


·Funzionale

OOP(Object Oriented Programming)

Programmazione strutturata Programmazione ad oggetti

rettangolo 2rettangolo 4

Problema complesso Sistema complesso



connettore 2 6connettore 2 7
rettangolo 3rettangolo 5

Scomposizione in procedure Scomposizione in entità interagenti (oggetti)

VANTAGGI DELLO STILE DI PROGRAMMAZIONE ORIENTATA AD OGGETTI

·parentesi graffa chiusa 8Facilità di lettura e comprensione del codice

·Rapidità nella manutenzione Qualità del

·Robustezza del programma software

·Riusabilità

JAVA


Java è un linguaggio di alto livello orientato agli oggetti, creato dal Sun Microsystem nel 1995.

Nel 2010 la Sun è stata acquistata da Oracle.

Java nasce anche per poter essere eseguito senza modifiche su diversi sistemi operativi ed elaboratori con architetture hardware diverse.

La portabilità è la capacità di un programma di essere eseguito su piattaforme diverse senza dover essere modificato e ricompilato.

Vediamo come viene realizzata in pratica la portabilità in Java:

Quando si compila il codice sorgente in Java, il compilatore genera il codice compilato, chiamato byte code.

Questo è un formato intermedio, indipendente dall’architettura ed è usato per trasportare il codice in modo efficiente tra le varie piattaforme hardware e software.

Questo codice non può essere eseguito da una macchina reale.

E’ un codice astratto generato per una macchina astratta, detta Java Virtual Machine (JVM).

Per essere eseguito su una macchina reale, il codice compilato (byte code) deve essere interpretato.

Significa che ogni istruzione della macchina su cui si sta eseguendo l’applicazione in quel momento, per questi motivi si può dire che Java è un linguaggio interpretato, anche se la produzione del byte code è effettuata con un operazione di compilazione.

L’ambiente di programmazione Java include un insieme di librerie contenenti classi e metodi di varia utilità:

·Java.lang: Collezione delle classi di base.
·Java.io: Libreria per gli accessi ai file e ai flussi di input/output.
·Java.awt: Libreria contenente le classi per la gestione dei componenti grafici.
·Java.net: Librerie per le applicazioni che scambiano dati attraverso la rete.
·Java.util: Classi di utilità varie (array dinamici,gestione della data, …).

PRIMO PROGRAMMA IN JAVA

Scriviamo , utilizzando blocco note di Windows il seguente testo:
class domanda

{

public static void main(String args[])



{ System.out.println("Quanti anni hai?");

}

}


Salviamolo con estensione .java: domanda.java

Per compilare il programma digitiamo in ambiente prompt dei comandi: javac domanda.java

La fase di compilazione genera un file compilato che ha estensione .class e rappresenta il byte code.

Per eseguire il programma attiviamo l’interprete java usando il comando: java domanda


·Public indica che il metodo è pubblico ed è visibile.

·Void indica che non ci sono valori di ritorno.

·Static indica che il metodo è associato alla classe e non può essere richiamato dai singoli oggetti della classe.

·(Sono indicati i parametri). Il metodo main possiede come parametro un array di stringhe indicato con(args[ ]) che corrisponde ai parametri passati dalla riga di comando quando viene eseguita l’applicazione.

·L’oggetto System.out indica lo standard output, System.out.println( ) è un metodo che scrive sullo standard output i suoi argomenti e torna a capo.
Java è case-sensitive, ogni istruzione deve terminare con il simbolo ;

I COMMENTI

Le righe che iniziano con // sono di commento.

La seconda forma di commento è /*……*/ come commento che occupa più stringhe oppure /**…..*/

VARIABILI E COSTANTI IN JAVA

Esempio: int prezzo, double altezza=2,5 (l’assegnazione viene indicata con uguale), final double yard_metro=0,914 (le costanti sono precedute da final).

TIPO DI DATO


Tipo

Dimensione

Valori

Byte

8 bit

Da -128 a 127

Short

16 bit

Da -32768 a 32767

Int

32 bit

Da -2147483648 a 2147483647

Long

64 bit

Da -263 a 263-1

TIPI A VIRGOLA MOBILE



Tipo

Dimensione

Precisione

Float

32 bit

Singola

Double

64 bit

Doppia

Precisione singola: 7 cifre decimali.

Precisione doppia: 16 cifre decimali.

TIPO DI DATO CARATTERE

Il tipo di dato carattere è definito usando 16 bit e la codifica UNICODE.

Java non utilizza la codifica ASCII per rappresentare caratteri.

La codifica UNICODE definisce un insieme di caratteri usando 2 byte.

I primi 128 caratteri sono equivalenti ai caratteri del codice ASCII.

Alcuni caratteri vengono rappresentati attraverso sequenze di escape: \n, \t, \\
LE STRINGHE

Non sono un tipo predefinito ma sono definite in una certa classe (string).

Le sequenze di escape possono essere usate in una stringa.
BOOLEANO

Il tipo booleano viene indicato con Boolean e le variabili di questo tipo possono assumere i valori true o false.


IL CASTING PER LA CONVERSIONE DEL TIPO

Quasi tutti i controlli di correttezza di tipo vengono eseguiti durante la fase di compilazione quindi di Java è fortemente tipizzato. Se si assegna un valore intero ad una variabile di tipo float, Java effettua automaticamente la conversione perché il tipo float è più grande. Questa conversione chiamata anche promozione è permessa perché solitamente non si ha perdita di dati. Quando si tenta di effettuare assegnamenti tra variabili ed espressioni con tipi che vanno in conflitto viene generato un errore, per esempio la conversione da float ad int non viene eseguita automaticamente.

Se vogliamo eseguire forzatamente l’assegnamento il programmatore deve indicare esplicitamente la sua volontà. Il casting è il meccanismo che consente al programmatore l’obbligo della conversione. Il casting si effettua anteponendo al valore da convertire. Tra parentesi tonde, il tipo di dato in cui sarà convertito.

Esempio: int num=(int) float num;


GESTIONE DELL’INPUT/OUTPUT

System.out.printl(“messaggio da visualizzare”);

L’oggetto System.out indica lo standard output.

Println( ) è un metodo che stampa sul video un parametro e inserisce un ritorno a capo.

Print( ) è un metodo che stampa sul video un parametro e non inserisce un ritorno a capo.
Class stampa

{

public static void main(String args[])



{

int numIntero=5;

float numReale=25.68f;

boolean trovato=false;

System.out.println(“numero intero= “+ numIntero);

System.out.println(“numero reale= “+ numReale);

System.out.println(“trovato= “+ trovato);

}

}



Nella dichiarazione del numero reale è stata aggiunta la lettera f dopo il numero altrimenti sarebbe stato interpretato come un double, l’aggiunta della f equivale ad un casting.

In alternativa si poteva scrivere float numReale=(float) 25.86;

Per le operazioni di input esiste un oggetto denominato System.in.

System.in viene mascherato da oggetti che forniscono maggiori funzionalità: la classe BufferedReader.


InputStreamReader input= new InputStreamReader(System.in);

BufferedReader tastiera= new BufferedReader(input);


Con queste dichiarazioni viene definito un oggetto tastiera di classe BufferedReader con l’operatore new che crea un nuovo oggetto.

La classe BufferedReader mette a disposizione il metodo readLine() che consente di leggere una riga per volta. Una riga viene considerata terminata quando viene premuto il tasto invio. Questo metodo restituisce solo stringhe,quindi se si vogliono acquisire valori numerici, si deve effettuare la conversione tra stringhe e numeri.

Esempio: String nome;

nome= tastiera.readLine();

int num;

leggiNumero=tastiera.readLine();

num=integer.valueOf(leggiNumero).intValue();

Gestione delle eccezioni

Quando si verifica un eccezione (ossia una situazione anomala) bisogna prevedere un blocco di istruzioni per gestire questa situazione. In java si utilizza il costrutto try{} catch{}

Esempio1:

String nome;

try

{

nome= tastiera.readLine();



}

catch(Exeption e) {}

Esempio2:

String legginumero;

int num;

try


{

leggiNumero=tastiera.readLine();


num=Integer.valueOf(leggiNumero).intValue();

}

catch(Exeption e)



{

System.out.println(“\nNumero non corretto!”);

return;

}

Esempio3:


import java.io.*;
class Es52
{
public static void main(String argv[])
{
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader tastiera=new BufferedReader(input);
String str;
try
{
str=tastiera.readLine();
}
catch(Exception e)
{return;}
System.out.println("Questa è la stringa letta: " + str);
}
}

Operatori di confronto: == ; != ; < ; <= ; > ; >=

Operatori booleani: && indica l’operazione AND

|| indica l’operazione OR

! indica l’operazione NOT

LE STRUTTURE DI CONTROLLO



Sequenza:

La struttura di sequenza, come in C++, viene realizzata posizionando le istruzioni una di seguito all’altra e separandole col ;



Selezione:

La struttura di selezione viene realizzata con il seguente costrutto:

If(condizione)

{

Istruzioni eseguite se la condizione è vera



}

Else


{

Istruzioni eseguite se la condizione è falsa

}

Selezione multipla



Switch(espressione)

{

Case 1: istruzioni break;



case 2: istruzioni break;

Default: istruzioni break;



}

Iterazione:

while(condizione)

{

Istruzioni



}

Ciclo indefinito: cicla per vero e la condizione è in testa.

Do

{

Istruzioni



}

While(condizione)

Ciclo indefinito: cicla per vero e la condizione è in coda.

For ( inizializzazione; condizione ; aggiornamento)

{

Istruzioni



}

Ciclo definito

ARRAY

Array monodimensionali:
In Java è necessario dichiarare un array e allocarlo e nel seguente esempio le due fasi venogno scritte contemporaneamente sulla stessa riga:

int vet[]= new int[5]


String nome[]= new String[10]

Array multidimensionali:
int mat[][]= new int[3][4]

IL METODO MAIN CON PARAMETRI

Esempio:

class parametri


{
public static void main( String args[])
{
System.out.println(“elenco parametri: “);
if(args.length==0){
System.out.println(“Nessun parametro”);
return;
}
else{
for(int i=0;i{
System.out.println(args[i]);

}

}


}
}
Esecuzione:

Javac parametri.java


Java parametri 45 –t rossi

Risultato a video:

Elenco parametri:
45
-t
rossi

LE ECCEZIONI

Un’eccezione è una struttura anomala che si verifica durante l’esecuzione del programma, una condizione anomala può essere una divisone per 0, oppure l’utilizzo di un indice in un array maggiore della sua dimensione fisica. Il programma usando particolari costrutti può tenere sotto controllo certe parti del codice e agire in modo opportuno se viene generata un’eccezione. La gestione delle eccezioni si realizza con il costrutto try…catch. Se vengono generalizzate delle eccezioni all’interno del blocco try il controllo dell’esecuzione passa al controllo catch. Dopo la parola catch si indica tra parentesi tonde l’eccezione che può verificarsi. Ci sono alcune eccezioni predefinite:

AritmeticException: segnala errori aritmetici;

IoException: generico errore di input-output.

Esempio:


class Eccezione

{

Public static void main(String args[])



{

Int a;


Int divisore=0;

try


{

a=15/divisore ;

}

Catch (AritmeticException e)



{

System.out.println(“divisione impossibile”);

return;

}

}



}

DICHIARAZIONE E UTILIZZO DI UNA CLASSE

Class NomeClasse

{

//attributi



//metodi

}

NomeClasse nomeOggetto //dichiarazione di un oggetto, i nomi degli oggetti con lettere minuscole, i nomi delle classi con lettera maiuscola



nomeOggetto=new NomeClasse(); //creazione dell’istanza nome oggetto

class Cerchio

{

Private dobule Raggio; //attributo



Public void setRaggio (double r); //metodo

{

Raggio=r;



}

Public double Area() ; //metodo

{

Return(Raggio*Raggio*Math.PI);



}

}

Class ProgCerchio



{

Public static void main(String args[])

{

Cerchio cerchioObj //dichiarazione dell’oggetto



cerchioObj= new Cerchio(); //creazione dell’istanza

cerchioObj.setRaggio(0.75);

system.out.println (“area del cerchio “+cerchioObj.Area());

}

}



Un programma si compone generalmente di diverse classi. Tali classi si possono trovare fisicamente in file diversi. Viceversa un file può contenere più classi. Se un file contiene più classi, solo quella con lo stesso nome del file sarà public e visibile all’esterno del file stesso. La classe principale deve avere una visibilità public e trovarsi in un file con il suo stesso nome. E’ possibile salvare ogni classe in un file distinto, purché memorizzato nella stessa cartella della classe principale. Dopo aver compilato separatamente i file sorgenti l’esecuzione del programma inizierà dalla classe principale.

GLI ATTRIBUTI

Gli attributi vengono chiamati anche variabili istanza e nella dichiarazione sono sempre preceduti dall’indicatore di visibilità:


  • Public: L’attributo è accessibile a qualsiasi altra classe;

  • Private: l’attributo non è accessibile alle altre classi, è nascosto all’interno di un oggetto(Information hiding)

  • Protected: l’attributo è accessibile solo alle sottoclassi e alle classi appartenenti allo stesso package di quello in cui è dichiarato

  • Package: se non si inserisce nessuna delle parole chiavi precedenti vuol dire che l’attributo è visibile solo dalle classe che appartengono allo stesso package.

  • Static: indica un attributo legato alla classe nel senso che se vengono creati più oggetti di quella classe esiste solo una copia dell’attributo

  • Final: invece se si vuol renderlo una costante. Esempio: public final int 10=10.

I METODI

Un metodo è caratterizzato da:

un nome;

un elenco di parametri;

un tipo di valore di ritorno;

un blocco di istruzioni;

un ambiente locale.

I livelli di visibilità di un metodo sono gli stessi visti per gli attributi.

COSTRUTTORI

Con l’allocazione dell’oggetto viene attivato in modo implicito un particolare metodo predefinito detto costruttore della classe. I costruttori vengono eseguiti automaticamente ogni volta che viene creato un nuovo oggetto e sono solitamente usati per l’inizializzazione dell’oggetto.

Esempio: aggiungiamo alla classe Cerchio un costruttore

Class Cerchio

{

Private double Raggio:



public Cerchio( double r) // costruttore

{

Raggio=r;



}

}

Quindi l’allocazione sarà: cerchioObj=new Cerchio(0.41)



Una classe può avere più metodi costruttori purché abbiano diverso numero e tipo di parametri. Chiamiamo questa situazione di moltiplicità overloading dei costruttori.

L’invocazione di un metodo avviene nel seguente modo:

nomeOggetto.metodo(parametri)

Nell’oop si usa il termine scambio di messaggi per indicare l’interazione tra oggetti, realizzata tramite l’invocazione dei metodi. Quando un oggetto vuole comunicare con un altro per eseguire un azione manda ad esso un messaggio. Il nome oggetto che precede il punto corrispondente al destinatario del messaggio. In ogni classe è implicitamente presente un oggetto speciale identificato dalla parola chiave THIS. Questa parola chiave costituisce un rifornimento all’oggetto medesimo.

Esempio:

public cerchio(double Raggio)

{ this.Raggio=Raggio; }

L’uso dello stesso nome consente di non inventare nomi diversi di variabile rendendo più semplice la lettura del codice. Il parametro raggio all’interno del costruttore diventa una variabile locale che maschera l’attributo dichiarato con lo stesso nome.

In java, i parametri possono essere passati ai metodi solo per valore.

I tipi di riferimento, vengono passati per indirizzo. L’array quindi non viene duplicato e viene creata una variabile locale che contiene la copia dell’indirizzo allo stesso array. Ne segue che le modifiche all’interno del metodo, fatte usando il parametro, modificano anche l’array originale.

La dichiarazione dell’oggetto crea una variabile vuota che contiene la parola chiave NULL. L’allocazione dell’oggetto inserisce nella variabile il riferimento all’area di memoria contenente i valori degli attributi dell’oggetto.

L’interfaccia di una classe indica l’elenco dei metodi pubblici, cioè l’insieme delle funzionalità utilizzabili dalle istanze della classe.

Array di oggetti

Esempio: Cerchio vetCerchio[]=new Cerchio[10] la dichiarazione e l’allocazione di un array di oggetti è la stessa degli array basati sui tipi predefiniti.

L’EREDITARIETA’

class Cerchio
{
private double raggio;
public Cerchio(double raggio)
{
this.raggio=raggio;
}
public void setRaggio(double raggio)
{
this.raggio=raggio;
}
public double area()
{
return (raggio*raggio* Math.PI);
}

public double circonferenza()


{
return(raggio*2*Math.PI);
}

}

class Cilindro extends Cerchio


{
private double altezza;
public Cilindro(double raggio, double altezza)
{
super(raggio);
this.altezza=altezza;
}
public void setAltezza (double altezza)
{
this.altezza=altezza;
}
public double volume()
{
return area()*altezza;
}

}

class ProgCilindro



{

public static void main(String args[])


{
Cilindro cilindroObj=new Cilindro(4.0,10.0);
System.out.println(“area di base= “ + cilindroObj.area());
System.out.println(“volume = “ + cilindroObj.volume());
}
}

POLIMORFISMO

Il polimorfismo indica la possibilità per i metodi di assumere forme, cioè implementazioni, diverse all’interno della gerarchia delle classi.

Nei linguaggi ad oggetti sono presenti due tipi di polimorfismo:



  • Overriding, o sovrapposizione dei metodi;

  • Overloading, o sovraccarico dei metodi.

L’overriding di un metodo consiste nel ridefinire, nella classe derivata, un metodo ereditato, con lo scopo di modificarne il comportamento. Il nuovo metodo deve avere lo stesso nome e gli stessi parametri del metodo sovrascritto.

Esempio7:

la classe cilindro eredita dalla classe cerchio il metodo area che calcola l’area del cerchio alla base del cilindro. Questo metodo area può essere sovrascritto per calcolare l’area della superficie totale del cilindro.

Il codice del metodo sovrascritto è il seguente:

public double area()
{
double areaBase, areaLaterale;
areaBase=super.area()*2;
areaLaterale=circonferenza()*altezza;
return areaBase+areaLaterale;
}

class Cerchio
{
private double Raggio;
public Cerchio(double Raggio)
{
this.Raggio=Raggio;
}
public void setRaggio (double Raggio)
{
this.Raggio=Raggio;
}
public double area()
{
return(Raggio*Raggio)*Math.PI;
}
public double circonferenza()
{
return(2*Raggio*Math.PI);
}

}

class Cilindro extends Cerchio


{
private double altezza;
public Cilindro (double Raggio, double altezza)

{ super(Raggio); this.altezza=altezza; }


public void setaltezza (double altezza)

{ this.altezza=altezza; }


public double volume()

{ return(super.area()*altezza); }


public double area()

{

double AreaBase, AreaLaterale;



AreaBase=super.area()*2;

AreaLaterale=circonferenza()*altezza;

return(AreaBase+AreaLaterale);

}

}




class ProgCilindro2

{

public static void main(String args[])



{

Cilindro cilindroObj=new Cilindro(4,10);

System.out.println("L'area del cilindro e': " +cilindroObj.area());

System.out.println("Il volume e': " +cilindroObj.volume());

} }

OVERLOADING



l’overloading di un metodo è la possibilità di utilizzare lo stesso nome per compiere operazioni diverse. Solitamente si applica ai metodi della stessa classe che si presentano con lo stesso nome ma con un numero o tipo diverso di parametri.

Un esempio di overloading è il metodo println.

Esistono diversi metodi println con lo stesso nome che vengono richiamate allo stesso metodo ma con parmetri diversi.
System.out.println(“Stringa”);

System.out.println(50);

System.out.println(7,12);
L’overloading è usato anche per offrire più costruttori ad una classe.

Esempio7:


class Numero

{

private int num;



public Numero()

{

num=0;



}

public Numero(int num)

{

this.num=num;



}

}
LE LIBRERIE

In java le librerie sono costituite da un insieme di classi già compilate. Per riferirsi alle librerie java usa il termine package. I package sono raggruppamenti che contengono più classi correlate. Alcuni esempi di package in JDK sono:

Java.applet, raggruppa le classi per gestire le applet;

Java.awt, raggruppa le classi usate per creare interfacce grafiche (pulsanti, menù, finestre);

java.io, raggruppa le classe per la gestione dei file e dell’ I/O;

Java.lang, raggruppa le classi di base per il linguaggio tra cui math,string;

java.net, raggruppa le classi per le applicazioni di rete;

java.util, raggruppa classi di varia utilità per la gestione della data,calendario,vettori.

LE STRINGHE

Le stringhe non sono un tipo di dato predefinito in java. Sono definite usando una classe chiamata String che è inclusa nel package java.lang. Per usare le stringhe in java si deve usare un oggetto di classe String.

String nome=new String(“Elena”);

Oppure String nome=”Elena”;
L’operatore di concatenazione tra stringhe è +.

I metodi principali della classe String sono:



  • Lenght, restituisce un numero corrispondente alla lunghezza della stringa.

  • charAT(int), restituisce il carattere che si trova nella posizione indicata dal parametro.

  • toLowerCase, to LapperCase, convertono tutti i caratteri.

  • Equals, controlla se la stringa che riceve come parametro è uguale a quella a cui viene applicato, oppure si può usare invece di equals ==.

PROGRAMMAZIONE GUIDATA DAGLI EVENTI

I programmi eseguiti da un elaboratore possono essere divisi in due categorie: programmi che eseguono loro compiti senza richiedere intervento di utenti, e altri che hanno bisogno di interagire con gli utilizzatori. Per esempio un programma che si preoccupa di tenere aggiornato un orologio non ha bisogno di input. Al contrario un programma che esegue calcoli su certi valori inseriti da un utente ha bisogno di interagire con lo stesso. Le interfacce possono essere a carattere o grafiche. Le interfacce a caratteri possono visualizzare solo caratteri e l’interazione avviene inserendo i comandi da tastiera. Le interfacce grafiche sono composte da immagini, icone, finestre, bottoni.

Le interfacce grafiche si indicano con il termine GUI (grapichal user interface). La OOP per gestire le interfacce grafiche usa la programmazione guidata dagli eventi, cioè ad ogni interazione dell’utente viene associato un evento che deve essere gestito richiamando un azione appropiata senza rispettare tempi prefissati. La generazione di un evento è causata da un azione effettuata dall’utente. Una volta generato un evento si deve provvedere alla sua gestione che viene demandata ad un gestore di eventi. Un gestore, detto anche handler, è la parte dell’applicazione software che si preoccupa di dare una risposta in base al tipo di evento ricevuto.

La parte grafica di java è contenuta nel package java.awt e java.swing.

l’awt (Abstract window toolkit) è il sistema utilizzato da java per definire un insieme di elementi grafici indipendenti della piattaforma su cui verranno visualizzati.

Swing rappresenta l’evoluzione di awt in quanto aggiunge nuovi componenti metodi e funzionalità. Una componente è un oggetto con una rappresentazione grafica e la sua caratteristica principale è quella di offrire un interazione con l’utente. Esempi di componenti sono: i pulsanti, i menù, le caselle di testo, le barre di scorrimento e cosi via. Un contenitore è un oggetto che può contenere le componenti, il compito del contenitore è quello di posizionare e di mensionare le componenti all’interno del contenitore stesso. Un contenitore comunemente usato è la finestra. Le classi di java che realizzano le componenti e i contenitori sono organizzate in una gerarchia delle componenti che ha come padre la classe component.


OBIECT









BUTTON










COMPONENT









CONTAINER










LABEL







I pannelli hanno lo scopo di organizzare i componenti nella finestra.

CREARE UNA FINESTRE GRAFICA COMPOSTA DA UN’ ETICHETTA E UN PULSANTE

Programma con libreria awt:

import java.awt.*;

class FinestraAwt

{

public static void main (String args[])



{

Frame frmF=new Frame();

Panel pnlP=new Panel();

Label lblL=new Label(“Etichetta”);

Button btnB=new Button(“Bottone”);

pnlP.add(lblL);

pnlP.add(btnB);

frmF.add(pnlP);

frmF.setSize(300,200);

frmF.setVisible(true);

}

}

Programma con libreria swing:



import javax.swing.*;

import java.awt.*;

class FinestraSwing

{

public static void main (String args[])



{

JFrame frmF=new JFrame();

JPanel pnlP=new JPanel();

JLabel lblL=new JLabel(“Etichetta”);

JButton btnB=new JButton(“Bottone”);

pnlP.add(lblL);

pnlP.add(btnB);

Container cntC=frmF.getContentPane();

cntC.add(pnlP);

frmF.setSize(300,200);

frmF.setVisible(true);

}

}



In Swing, l’aggiunta al contenitore principale viene eseguito tramite un ulteriore contenitore intermedio (Container) che rappresenta il contentpane, pannello del contenuto della finestra JFrame. Il metodo getContentPane rende disponibile questo contenitore. Per chiudere la finestra, occorre gestire l’evento di chiusura associando ad esso un’istruzione che causa la fine del programma. Non avendo previsto nel programma la gestione di questa operazione, per chiudere la finestra bisogna premere la combinazione Ctrl+C dal Prompt dei comandi.

ETICHETTE

L’etichetta è rappresentata dalla classe JLabel e può contenere solo una riga di testo. L’etichetta può essere modificata solo da programma ma non dall’utente.

Un’etichetta può essere definita attraverso tre diversi costruttori:



  • JLabel()
    costruttore senza parametri che crea un’etichetta vuota.

Esempio:

import java.awt.*;

import javax.swing.*;

class JLabel1

{

public static void main(String args[])



{

JFrame frmF=new JFrame();

JLabel lblL=new JLabel();

frmF.add(lblL);

frmF.setSize(200,200);

frmF.setVisible(true);

}

}


  • JLabel(String)
    crea un’etichetta con la stringa passata come parametro e l’allinea a sinistra.

Esempio:

import java.awt.*;

import javax.swing.*;

class JLabel2

{

public static void main(String args[])



{

JFrame frmF=new JFrame();

JLabel lblL=new JLabel("Etichetta");

frmF.add(lblL);

frmF.setSize(200,200);

frmF.setVisible(true);

}

}


  • JLabel(String, int)
    crea un’etichetta contenente come testo la stringa passata come parametro e il parametro intero indicherà l’allineamento della stringa

Esempio:

import java.awt.*;

import javax.swing.*;

class JLabel3

{

public static void main(String args[])



{

JFrame frmF=new JFrame();

JLabel lblL=new JLabel("Etichetta",30);

frmF.add(lblL);

frmF.setSize(200,200);

frmF.setVisible(true);

}

}
Le costanti statiche definite all’interno della classe sono: JLabel.LEFT, JLabel.RIGHT, JLabel.CENTER.



I metodi della JLabel sono:

  • setText(String)
    consente di modificare il testo.

  • setForeground(Color)
    modifica il colore del testo

  • setBackground(Color)
    modifica il colore dello sfondo.

Esempio:

lblNome.setText(“Ciao”);

lblNome.setForeground(Color.red);

La classe Color presenta le costanti statiche che possono essere usate per il colore (black, blue, green, magenta, orange, pink, red, white, yellow, cyan, gray).

La classe JLabel inoltre eredita tutti i metodi della classe JComponent e della classe Object . Infatti i metodi setForegroud() e setBackground() sono ereditati dalla classe JComponent, mentre il metodo setText() è un metodo proprio della classe JLabel.

PULSANTI


I pulsanti sono rappresentati dalla classe JButton. Solitamente contengono una stringa e sono usati per invocare un’azione quando vengono premuti dall’utente. La stringa che appare nel pulsante indica quindi un’azione da compiere ed è quindi solitamente un verbo. Il costruttore può essere generico oppure contiene come parametri la stringa da visualizzare.

Esempio:


JButton btnOk= new JButton(“OK”);

E` possibile disattivare il pulsante con il metodo setEnabled(boolean).

Esempio:

btnOk.setEnabled(false);

Esempio:

import javax.swing.*;


import java.awt.*;
class SetEnabled
{
public static void main(String arg[])
{
JFrame frmF=new JFrame();
JButton btnB=new JButton("ok");
frmF.add(btnB);
frmF.setSize(100,100);
frmF.setVisible(true);
btnB.setEnabled(false);
}
}

CASELLE DI TESTO

Sono realizzate dalla classe JTextField. La casella di testo è composta da una sola riga che può essere usata per l’input o l’output di stringhe.

I quattro costruttori di questa classe consentono di impostare la stringa da visualizzare e il numero di colonne della casella:



  • JTextField()

  • JTextField(String)

  • JTextField(int)

  • JTextField(String, int)

La classe JTextField eredita tre metodi molto utili dalla classe JTextComponent:

  • setText(String)

  • getText()

  • setEditable(boolean)

Esempio:

txtPrezzo.setEditable(false);

Esempio 2:

import javax.swing.*;


import java.awt.*;
class CasellaDiTesto
{
public static void main(String arg[])
{
JFrame frmF=new JFrame();
JPanel pnlP=new JPanel();
JTextField txtSenzaPar=new JTextField();
JTextField txtConPar=new JTextField("Ciao 2");
JTextField txtIntPar=new JTextField(3);
JTextField txtStringInt=new JTextField("Ciao 3",8);
txtSenzaPar.setText("Ciao");
txtConPar.setEditable(false);
txtIntPar.getText();
pnlP.add(txtSenzaPar);
pnlP.add(txtConPar);
pnlP.add(txtIntPar);
pnlP.add(txtStringInt);
frmF.add(pnlP);
frmF.setSize(200,150);
frmF.setVisible(true);
}
}

AREE DI TESTO

La classe JTextArea consente di creare un’area di testo composta da più righe.

I costruttori sono simili a quelli delle caselle di testo con l’aggiunta di un parametro che indica il numero di righe:



  • JTextArea()

  • JTextArea(int, int)

  • JTextArea(String)

  • JTextArea(String, int, int, int)

Il terzo int è una costante interna che specifica la visualizzazione delle barre di scorrimento:

SCROLLBARS_BOTH, SCROLLBARS_VERTICAL, SCROLLBARS_ONLY, SCROLLBARS_HORIZONTAL_ONLY, SCROLLBARS_NONE.

L’area di testo può usare gli stessi metodi della casella di testo.



  • setText(String)
    cancella il testo precedente e aggiunge il nuovo testo

  • getText()
    legge tutto il contenuto del testo

  • append(String)
    per inserire un nuovo testo alla fine dell’area senza cancellare il contenuto.

Esempio:

import javax.swing.*;


import java.awt.*;
class AreaDiTesto
{
public static void main(String arg[])
{
JFrame frmF=new JFrame();
JPanel pnlP=new JPanel();
JTextArea txtSenzaPar=new JTextArea();
JTextArea txtIntPar=new JTextArea(4,5);
JTextArea txtStringPar=new JTextArea("Ciao 2");
JTextArea txtStringInt=new JTextArea("Ciaooo",8,5);
txtSenzaPar.setText("Ciao");
txtIntPar.getText();
txtStringPar.append("!");
pnlP.add(txtSenzaPar);
pnlP.add(txtIntPar);
pnlP.add(txtStringPar);
pnlP.add(txtStringInt);
frmF.add(pnlP);
frmF.setSize(200,150);
frmF.setVisible(true);
}
}

LE CASELLE COMBINATE (COMBO BOX)

Le caselle combinate raggruppano un elenco di voci e consentono, tramite un menu a tendina, la scelta di una singola voce. Questo elemento grafico è rappresentato dalla classe JComboBox.

La costruzione di una combo box avviene attraverso due fasi:



  1. creazione del oggetto

  2. aggiunta delle voci

la creazione avviene attraverso un costruttore senza parametri. Le voci vengono aggiunte mediante il metodo addItems(String).

Esempio:


JComboBox cboColori= new JComboBox();

cboColori.addItems(“rosso”);

cboColori.addItems(“verde”);

LE CASELLE DI CONTROLLO (CHECK BOX)

La casella di controllo è un elemento grafico che gestisce solo due stati, corrispondenti ai valori booleani true e false, se la casella la il segno di spunta si associa il valore true.

Questo elemento grafico viene implementato con la classe JCheckBox che mette a disposizione I pulsanti a due stati, se l’utente fa click sulla casella ne causa il cambio di stato. Ogni casella di control è fornita di un’etichetta che viene usata per spiegare all’utente il significato della casella.

Esempio:

JCheckBox ckbScelta= new JCheckBox(“prima scelta”);

Il costruttore è JCheckBox(String, boolean).

La classe GridLayout permette di utilizzare una griglia.



Ecco un esempio completo di tutti i componenti:

import java.awt.*;


import javax.swing.*;
class Componenti
{
public static void main(String[] args)
{
JFrame frmF = new JFrame("Ecco i prncipali componenti della GUI");
JPanel pnlP = new JPanel();
JLabel lblEtichetta = new JLabel("Questa è un'etichetta");
JButton btnPulsante = new JButton("Questo è un pulsante");
JTextField txtCasellaTesto = new JTextField("inserire qui il testo", 30);
JTextArea txtAreaTesto = new JTextArea("inserire in questa area il testo", 4,30);
JCheckBox chkCheck = new JCheckBox("scelta già spuntata",true);
ButtonGroup radioGroup = new ButtonGroup();
JRadioButton chkC1 = new JRadioButton("1 scelta spuntata",true);
JRadioButton chkC2 = new JRadioButton("2 scelta non spuntata",false);
radioGroup.add(chkC1);
radioGroup.add(chkC2);
Choice cboC = new Choice();
cboC.addItem("prima scelta");
cboC.addItem("seconda scelta");
pnlP.add(lblEtichetta);
pnlP.add(btnPulsante);
pnlP.add(txtCasellaTesto);
pnlP.add(txtAreaTesto);
pnlP.add(chkCheck);
pnlP.add(chkC1);
pnlP.add(chkC2);
pnlP.add(cboC);
Container cntC = frmF.getContentPane();
cntC.add(pnlP);
frmF.setSize(600,500);
frmF.setLocation(200,200);
frmF.setVisible(true);
}
}

Gestione degli eventi

Il software deve riconoscere quando l’utente compie le azioni e predisporre le operazioni da eseguire in corrispondenza delle azioni.
Il primo è un compito affidato al sistema che gestisce gli eventi.
Il secondo è affidato al programmatore che scrive il codice da eseguire per ogni possibile azione dell’utente.
In java gli eventi vengono gestiti solo se è stato registrato un gestore.
Gli eventi sono generati a partire da un oggetto chiamato origine, tutte le componenti sono possibili oggetti di origine.
Uno o più ascoltatori possono essere registrati nell’oggetto origine.
Un ascoltatore è un oggetto.
Per realizzare quindi la gestione degli eventi è necessario:
1)Creare uno o più ascoltatori in base agli eventi che si vogliono gestire;
2)Registrare l’ascoltatore in un oggetto origine ;
3)Gestire l’evento eseguendo il metodo associato;
Esempio:

import java.awt.*;

import java.awt.event.*;

public class PulsanteConEvento

{

TextField txtT;



public PulsanteConEvento()

{

Frame frmF = new Frame("Pulsante con evento");



txtT = new TextField(30);

Button btnPulsante = new Button("Saluta");

frmF.setLayout(new FlowLayout()); //mette in colonna le componenti

btnPulsante.addActionListener(new ascoltaPulsante());

frmF.add(txtT);

frmF.add(btnPulsante);

frmF.pack();

frmF.setSize(600,500);

frmF.setLocation(200,200);

frmF.setVisible(true);

}

private class ascoltaPulsante implements ActionListener



{

public void actionPerformed(ActionEvent e)

{

txtT.setText("Buongiorno ragazzi");



}

} // fine classe ascoltaPulsante

} // fine classe PulsanteConEvento

import java.awt.*;

import java.awt.event.*;

public class ProgPulsanteConEvento

{

public static void main(String[] args)



{

PulsanteConEvento PulsanteConEventoobj = new PulsanteConEvento();

}

}

class Penna



{

private int inchiostroNero;

public Penna(int inchiostroNero)

{

this.inchiostroNero=inchiostroNero;



}

public void setInchiostroNero(int inchiostroNero)

{

this.inchiostroNero=this.inchiostroNero+inchiostroNero;



}

public void scrivi(int caratteri)

{

inchiostroNero=inchiostroNero-caratteri;



}

public int getInchiostroNero()

{

return inchiostroNero;



}

}

class PennaMulticolore extends Penna



{

private int inchiostroRosso;

public PennaMulticolore(int inchiostroNero, int inchiostroRosso)

{

super(inchiostroNero);



this.inchiostroRosso=inchiostroRosso;

}

public void setInchiostroRosso (int inchiostroRosso)



{

this.inchiostroRosso=this.inchiostroRosso+inchiostroRosso;

}

public void scriviColore(int caratteri,int col)



{

if(col==1){scrivi(caratteri); }

else{inchiostroRosso=inchiostroRosso-caratteri;}

}

public int getInchiostroRosso()



{

return inchiostroRosso;

}

}

class ProgPenna



{

public static void main(String argv[])

{

PennaMulticolore pennaObj;



pennaObj=new PennaMulticolore(50,25);

System.out.println("Il livello dell'inchiostro nero e' " + pennaObj.getInchiostroNero());

System.out.println("Il livello dell'inchiostro rosso e' " + pennaObj.getInchiostroRosso());

pennaObj.scriviColore(30,1);

pennaObj.scriviColore(30,0);

System.out.println("Il livello dell'inchiostro nero e' " + pennaObj.getInchiostroNero());

System.out.println("Il livello dell'inchiostro rosso e' " + pennaObj.getInchiostroRosso());

pennaObj.setInchiostroNero(100);

pennaObj.setInchiostroRosso(40);

System.out.println("Il livello dell'inchiostro nero e' " + pennaObj.getInchiostroNero());

System.out.println("Il livello dell'inchiostro rosso e' " + pennaObj.getInchiostroRosso());

pennaObj.scriviColore(110,1);

pennaObj.scriviColore(110,0);

System.out.println("Il livello dell'inchiostro nero e' " + pennaObj.getInchiostroNero());

System.out.println("Il livello dell'inchiostro rosso e' " + pennaObj.getInchiostroRosso());

}

}



Esercizio Macchine (utilizzo dei Thread)

public class Macchine extends Thread

{

public Macchine(String nome_thread)



{

super(nome_thread);

}

public void run()



{

for (int i=0;i<7;i++)

{

System.out.println(getName());



}

}

public static void main(String[] str)



{

Macchine auto1=new Macchine("Macchina 1");

auto1.setPriority(10);

Macchine auto2=new Macchine("Macchina 2");

auto2.setPriority(7);

Macchine auto3=new Macchine("Macchina 3");

auto3.setPriority(1);

auto1.start();

auto2.start();

auto3.start();

}

}

Esercizio ThreadApp(utilizzo dei Thread, pallino animato)



import java.awt.Graphics;

import java.awt.Color;

import java.awt.Event;

import java.awt.*;

import javax.swing.*;

public class ThreadApp

{

public static void main(String args[])



{

JFrame f = new JFrame("Disegno animato");

f.setSize(350,150);

f.setLocation(1,1);

TPallino t1 = new TPallino(Color.red,100);

f.getContentPane().add(t1);

f.setVisible(true);

Thread runner1 = new Thread(t1);

runner1.start();

}

}



class TPallino extends JComponent implements Runnable

{

int xpos;



int raggio;

int vel=100;

Color colore;

public TPallino(Color c,int r)

{

xpos=0;


raggio=r;

colore=c;

}

public void run()



{

while(true)

{

for (xpos=5+raggio/4;xpos<=105;xpos+=4)



{

repaint();

try{Thread.sleep(100);}

catch(InterruptedException e){}

}

for (xpos=105;xpos>5;xpos-=4)



{

repaint();

try{Thread.sleep(100);}

catch(InterruptedException e){}

}

}

}



public void paint(Graphics g)

{

g.setColor(colore);



g.fillOval(xpos,5,raggio/2,raggio/2);

}

}



Esercizio MainProvaThreadBottoni(utilizzo dei Thread, pallino animato con bottoni)

import java.awt.Graphics;

import java.awt.Color;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

class ProvaThreadBottoni

{

Thread runner;



public ProvaThreadBottoni()

{

JFrame F1=new JFrame("Controllo");



JButton INIZIA=new JButton("INIZIA");

JButton STOP=new JButton("STOP");

JButton RIAVVIA=new JButton("RIAVVIA");

F1.setSize(300,200);

F1.setLocation(50,50);

F1.getContentPane().setLayout(new FlowLayout());

INIZIA.addActionListener(new ascoltaBottone());

STOP.addActionListener(new ascoltaBottone());

RIAVVIA.addActionListener(new ascoltaBottone());

F1.getContentPane().add(INIZIA);

F1.getContentPane().add(STOP);

F1.getContentPane().add(RIAVVIA);

F1.setVisible(true);

JFrame F2=new JFrame("Disegno");

F2.setSize(300,200);

F2.setLocation(1,1);

TPallino t= new TPallino();

F2.getContentPane().add(t);

F2.setVisible(true);

runner=new Thread(t);

}

private class ascoltaBottone implements ActionListener



{

public void actionPerformed(ActionEvent e)

{

String bottone=e.getActionCommand();



if(bottone.equals("INIZIA"));

if(!runner.isAlive())

runner.start();

if(bottone.equals("STOP"));

runner.suspend();

if(bottone.equals("RIAVVIA"));

runner.resume();

}

}



}

class TPallino extends JComponent implements Runnable

{

int xpos;



public void run()

{

while(true)



{

for (xpos=5;xpos<=150;xpos+=4)

{

repaint();



try{Thread.sleep(100);}

catch(InterruptedException e){}

}

for (xpos=150;xpos>5;xpos-=4)



{

repaint();

try{Thread.sleep(100);}

catch(InterruptedException e){}

}

}

}



public void paint(Graphics g)

{

g.setColor(Color.white);



g.fillRect(0,0,100,100);

g.setColor(Color.blue);

g.fillOval(xpos,5,90,90);

}

}



public class MainProvaThreadBottoni

{

public static void main(String args[])



{

ProvaThreadBottoni kk=new ProvaThreadBottoni();

}

}

Le applet



Un applet è un applicazione java che viene eseguita all’interno di un browser.

Le applet presentano alcune caratteristiche che le differenziano dalle altre applicazioni:



  • Un’applet non ha il metodo main;

  • Un’applet è un oggetto grafico, contenitore di awt e swing con le caratteristiche di un pannello;

  • Un’applet non può leggere né modificare file nel sistema client;

  • Un’applet non può modificare file né verificare quali programmi sono installati sul disco;

  • Un’applet non può eseguire programmi sul sistema client;

  • Un’applet non può utilizzare librerie del sistema client.

Esempio 1 (creare un’applet) :

CiaoMondo.java

import java.applet.*;

import javax.swing.*;

import java.awt.*;

public class CiaoMondo extends JApplet

{

public void init()



{

Container sfondo=getContentPane();

sfondo.setLayout(new FlowLayout());

JLabel miaLabel=new JLabel("Ciao, sono la vostra prima applet!");

sfondo.add(miaLabel);

}

}



CiaoMondo.html





Questa pagina web contiene un'applet java





Applet non eseguibile.






Condividi con i tuoi amici:


©astratto.info 2019
invia messaggio

    Pagina principale