Appunti Java

Appunti Java

 

 

Appunti Java

  
Nome file: Appunti di informatica.

Appunti di informatica                                                


Java

Stream.

Uno stream è una sequenza di byte che possono rappresentare qualsiasi valore, dalla quale si possono "leggere" o sulla quale si possono "scrivere" dei dati.

File (in generale).

Un file è una sequenza di byte a cui è associato un nome che permette di distinguere una sequenza dall’altra. In Java i file possono essere visti come dei flussi (stream). Il nome del file a livello di Java diventa URL che è un indicazione che mi permette di recuperare il nome del file in un sistema più ampio.Un file serve per conservare l’informazione mentre uno stream serve per comunicarla.
Un byte è costituito da 8 bit.

Numero magico.

Sono dei byte che identificano un programma.

Estensione.

L’estensione di un file è la parte finale del nome del file che ne specifica il tipo.

Nome logico.

Il nome logico del file è un nome interno che viene utilizzato per dire cosa fare su un file, è una variabile interna al programma.

Nome fisico.

Il nome fisico è il nome che serve ad identificare un file ed è valido all’esterno del programma.

Classe File.

La classe File rappresenta un file, non tanto il suo contenuto quanto il file com’essenza. La classe File mi rappresenta un file dal punto di vista dell’accessibilità. Un file può essere una cartella. E’ possibile usare la classe File per modificare il File System. La classe File ha tre costruttori:

  • Il primo costruttore File(String pathname)crea un oggetto di classe File ed  ha come parametro una stringa che è il nome del file.
  • Il secondo costruttore File(String parent, String child) crea un oggetto di classe File ed ha due parametri. Il primo parametro è il percorso, il secondo è il nome del file
  • Il terzo costruttore File(File parent, String child)crea un oggetto della classe File ed ha due parametri. Il primo parametro è un file che descrive la cartella in cui si trova il file, con il nome indicato sulla stringa, il secondo è il nome del file.

N.B.
Una cartella dal punto di vista di Java è un file.

Alcuni  metodi di File.

String[ ] list( ) : metodo che ritorna una matrice di stringhe che sono i nomi del file contenuti nel file se questo è una cartella.
File[ ] listFiles( ) : metodo che ritorna una matrice di file.
long lastModified( ) : metodo che ritorna il numero di milli-secondi che rappresenta l’ora, i minuti e i milli-secondi dell’ultima modifica del file.
boolean mkDir( ) : metodo che crea una cartella.
boolean renameTo(File dest) : metodo che cambia il nome del file.
boolean delete( ) : metodo che cancella il file.
String getName( ) : metodo che ritorna la parte finale del nome del file aperto.
String getParent( ) : metodo che ritorna il percorso del file senza il nome del file.
boolean exists( ) : metodo che ritorna vero se il file esiste.
long length( ): metodo che ritorna il numero di byte del file.
boolean isDirectory( ) : metodo che dice se il file è una cartella.
String getPath( ) : metodo che converte il nome astratto in una stringa un po’ particolare. Questa stringa è la cartella dove si trova il file.
File getAbsolutePath( ) : metodo che ritorna il percorso e il nome del file assieme.

InputStream.

InputStream è una classe astratta e quindi non si può neanche implementarla. E’ una sequenza di byte in ingresso. Un inputStream generico prevede di recuperare un byte alla volta.

SequenceInputStream.

La classe SequenceInputStream è sotto-classe di InputStream. SequenceInputStream permette di vedere più inputStream come se fossero un'unica sequenza. Questa classe ha i suoi metodi che permettono di leggere un byte e sovra-scrive alcuni metodi di InputStream. SequenceInputStream ha due costruttori:

  • Il primo costruttore SequenceInputStream(InputStream primo, InputStream secondo)crea un oggetto della classe SequenceInputStream e permette di concatenare solamente due file.
  • Il secondo costruttore SequenceInputStream(Enumeration flussi) crea un oggetto della classe SequenceInputStream ed  utilizza la classe Enumeration.

BufferedInputStream.

Con  il BufferedInputStream si leggono dei dati e questi vengono messi dentro ad un buffer. Quando viene richiesto un byte il BufferedInputStream preleva dall’inputStream che sta filtrando tanti byte fino a riempire la dimensione del buffer e restituisce il primo byte letto a chi lo ha chiesto. Nelle letture successive il BufferedInputStream legge l’informazione dal buffer e se ve n’è di disponibile. Al costruttore di BufferedInputStream gli viene passato un oggetto di classe InputStream che è quello da cui preleva l’informazione. La classe BufferedInputStream ha i metodi di InputStream e in più ha il metodo skip( ). Questo metodo permette di saltare alcuni byte.

BufferedOutputStream.

Il BufferedOutputStream è analogo al BufferedInputStream. Quando si scrive un byte sul BufferedInputStream il BufferedOutputStream lo mette dentro ad un buffer finché c’è spazio. Quando viene chiamato il flush( ) viene preso il contenuto del buffer e viene spedito tutto in una volta all’output. Al costruttore della classe BufferedOutputStream gli viene passato un oggetto di classe OutputStream.

DataInputStream.

Permette di prelevare l’informazione in maniera da conservare dei tipi semplici su questo flusso di byte. Permette di leggere a chi lo richiede diversi tipi semplici che vengono prelevati da DataOutputStream. Se si vuole leggere da DataInputStream un intero ho a disposizione il metodo readInt( ). Questo metodo preleva dal flusso quattro byte e restituisce un valore intero. Per gli altri tipi semplici si hanno a disposizione i metodi readShort( ), readDouble( ) eccetera.  I caratteri sono trattati in una maniera particolare perché c’è la codifica ASCII. Questa codifica è su un byte  e permette almeno duecentocinquantacinque valori diversi.

DataOutputStream.

Anche su DataOutputStream posso dare diversi tipi semplici e questa classe li trasforma in una sequenza di byte. Su DataOutputStream per mandare fuori un integer ho a disposizione il metodo writeInt(int i). Come per DataInputStream anche per DataOutputStream per gli altri tipi semplici si hanno i metodi writeDouble(double i), writeShort(int i) eccetera. Il metodo writeChars(String s) permette di spedire come sequenza di caratteri una stringa.

FileInputStream.

Fa diventare uno stream qualcosa che si trova residente su un file. L’informazione viene prelevata da un file e viene trasformata in flusso. Con FileInputStream leggo un file binario e posso leggere o un singolo byte o delle matrici di byte. I costruttori della classe FileInputStream sono tre e sono:

  • Il primo costruttore FileInputStream(File f) crea un oggetto della classe FileInputStream ed ha come parametro un oggetto di classe File.
  • Il secondo costruttore FileInputStream(FileDescriptor fdobj) crea un oggetto della classe FileInputStream ed ha come parametro un oggetto di classe FileDescriptor.
  • Il terzo costruttore FileInputStream(String name) crea un oggetto della classe FileInputStream ed ha come parametro una stringa.

FileOutputStream.

Preleva un flusso e lo va a depositare su un file su memoria di massa.

FileReader.

Questa classe serve per leggere un file di testo ed è un flusso che viene prelevato da un file. I reader sono degli stream di caratteri.

FiltrerStream.

Filtrano l’informazione che arriva da una parte e producono un flusso d’informazione da un'altra parte in modo più elaborato. Aumentano le funzionalità dello stream.

StreamTokenizer.

La classe StreamTokenizer prende un flusso in ingresso e lo trasforma in token permettendo che questo token sia letto uno alla volta. Lo StreamTokenizer può riconoscere identificatori, stringhe quotate, numeri e vari stili di commenti. Nella variabile int ttype si trova un codice che dice il tipo del token appena letto. Nella variabile double nval si trova invece, il valore del numero letto mentre nella variabile String sval si trova la parola letta.
N.B.
Un token è una prima sequenza di caratteri non interrotta.
Questa classe ha quattro costanti :

  • int TT_WORD : è una costante che indica che il token è una parola.
  • int TT_NUMBER : è una costante che indica che il token è un numero.
  • int TT_EOL : è una costante che indica che è stata raggiunta la fine della riga.
  • int TT_EOF : è una costante che indica che è stata raggiunta la fine del file.

Il costruttore di questa classe è:

  • StreamTokenizer(Reader r)  crea un token che interpreta il corrente flusso di caratteri ed ha come parametro un oggetto di classe Reader.
Alcuni metodi di StreamTokenizer.

void commentChar(int ch) : metodo che specifica che l’argomento carattere inizia una singola linea di commento. Il parametro ch rappresenta il carattere.
int lineno( ) : metodo che ritorna l’attuale numero di linea.
void ordinaryChars(int low, int hi) : metodo che specifica che tutti i caratteri c nel range di c compreso tra low e hi sono ordinari in questo tokenizer. I parametri low e hi rappresentano rispettivamente il punto più basso del range e quello più alto.
void ordinaryChar(int ch) : metodo che specifica che il carattere è ordinario in questo tokenizer. Il parametro ch rappresenta il carattere. 
void parseNumbers( ) : metodo che specifica che i numeri dovrebbero essere trasformati da questo tokenizer.
String toString( ) : metodo che ritorna la stringa che rappresenta il corrente flusso di token.
void wordChars(int low, int hi) : metodo che specifica che tutti i caratteri c nel range di c compreso tra low e hi costituiscono una parola. I parametri low e hi rappresentano rispettivamente il punto più basso del range e quello più alto.
void resetSyntax( ) : metodo che resetta la tavola della sintassi di questo tokenizer così che tutti i caratteri sono ordinari.
int nextToken( ) : metodo che estrae il token successivo che viene posto nel campo pubblico sval (se è una stringa) o nval (se è un numero). Il valore restituito da nextToken( ) indica se si tratta di un numero o di una stringa.
void whiteSpaceChars(int low, int hi) : metodo che specifica che tutti i caratteri c nel range di c compreso tra low e hi sono separatori. I parametri low e hi rappresentano rispettivamente il punto più basso del range e quello più alto.
void slashStarComments(boolean flag) : metodo che determina se oppure no il tokenizer riconosce i commenti nello stile di C. Il parametro flag è vero se riconosce e ignora i commenti nello stile di C.
void slashSlashComments(boolean flag) : metodo che determina se oppure no il tokenizer riconosce i commenti nello stile di C + +. Il parametro flag è vero se riconosce i commenti nello stile di C + +.
void eolIsSignificant(boolean flag) : metodo che determina se oppure no, i fine linea sono trattati come tokens. Il parametro flag è vero se indica che i caratteri fine linea sono token separati, è falso se indica che i caratteri fine linea sono spazi bianchi.

RandomAccessFile.

Questa classe consente di accedere ad un file sia in lettura che in scrittura partendo da posizioni qualunque. Questa classe implementa due interfacce: DataInput e DataOutput. Queste due interfacce sono l’insieme dei metodi presenti nelle classi DataInputStream e DataOutputStream. La classe RandomAccessFile ha due costruttori:

  • Il primo costruttore RandomAccessFile(File file, String mode) crea un oggetto di classe RandomAccessFile da leggere e da scrivere in un file specificando l’argomento File.
  • Il secondo costruttore RandomAccessFile(String name, String mode) crea un oggetto di classe RandomAccessFile da leggere e da scrivere in un file con il nome specificato. Questo costruttore ha come parametro il nome del file e il modo che può essere “r”(lettura) o “rw”(lettura e scrittura).
Alcuni metodi di RandomAccessFile.

void seek(long pos) : metodo che dice dove incomincio a leggere o a scrivere.
String readLine( ) : metodo che permette di leggere una riga, da dove sono posizionato, fino alla fine della riga.
void setLength(long newLength) : metodo che permette di troncare un file o di allungarlo.
long getFilePointer( ) : metodo che fa l’opposto del metodo seek( ). Ritorna la posizione da cui si parte per leggere.
void readFully(byte[ ] b) : metodo che permette di prelevare dal file un blocco di byte.

Thread.

I Threads sono una sequenza di istruzioni. Dentro un thread posso creare un nuovo thread, posso lanciare un'altra sequenza di istruzioni. L’istanza di questa classe è un qualche cosa che mi rappresenta una certa sequenza di istruzioni. Questa classe ha tre metodi che sono qui elencati: start( ), run( ) e stop( ). Il metodo start( ) mette il thread nella coda dei processi pronti per l’esecuzione, nel metodo run( ) ci sarà quello che deve essere fatto durante la vita del thread. Infine nel metodo stop( ) c’è tutto quello che deve essere fatto quando l’oggetto si ferma. L’interfaccia Runnable è un interfaccia che prevede un solo metodo che è il metodo run( ).
N.B.
Il metodo run( ) nella classe Thread non fa niente!

Modi per creare un thread.

Ci sono due modi per creare un thread:

  • Si può utilizzare il costruttore Thread( ) il quale viene usato all’interno dei costruttori delle classi che estendono la classe Thread.
  • Si può utilizzare il costruttore Thread(Runnable target) il quale si aspetta come parametro un istanza di una classe che implementa l’interfaccia Runnable.

N.B.
Se creo una classe che estende la classe Thread il suo oggetto è già un thread, mentre se creo una classe che implementa l’interfaccia Runnable, il suo oggetto è un oggetto che può essere mandato in esecuzione tramite un thread.

                                               Richiesta di servizio start( ) a un Thread

 

                       

 

                       

 

Processo.

Il processo è l’esecuzione di una sequenza di istruzioni. Il processo viene creato, viene inserito in coda e da qui può essere messo in pausa e quindi sospeso. Quando questo è sospeso il processo aspetta che avvenga un qualche evento, si mette in attesa finché la sua attesa non viene interrotta e poi viene inserito nuovamente in coda. Oppure il processo può morire diventando “zombi” per poi essere definitivamente eliminato. Quando un processo è zombi, possiede ancora un valore che deve essere usato ed aspetta che qualcuno gli raccolga l’informazione.

Ciclo di vita del processo.

Metodo paint.

Per disegnare un oggetto deve sovra-scrivere il metodo paint che ha come parametro un oggetto della classe Graphics che mi fornisce la descrizione dell’oggetto che vado a rappresentare.

Graphics.

Dentro la classe Graphics ci sono dei metodi che permettono di disegnare linee, rettangoli ed altre forme.

Alcuni metodi della classe Graphics.

void fillRect(int x, int y, int larghezza, int altezza) : disegna il rettangolo pieno.
void drawRect(int x, int y, int larghezza, int altezza) : disegna il rettangolo vuoto.
void setColor(Color c) : determina il colore utilizzato da quel momento in poi.    

Von Neumann.

Disse che all’interno del calcolatore vi erano un agente (CPU) che eseguiva le cose ed una memoria. La CPU preleva l’istruzione dalla memoria, la interpreta, la esegue modificando eventualmente i dati ed esegue l’istruzione successiva. La memoria nella struttura di Von Neumann è composta da una zona dati e istruzioni che sono rispettivamente lo stato ed il controllo.
)                                             

Enumeration.

La classe Enumeration è simile alla classe Vector. La classe Enumeration è un insieme di oggetti enumerati. Gli oggetti di Enumeration vengono ritornati da metodi standard.                                                                           

Nozioni generali.

Switch.

E’ un enunciato che fa cose diverse a seconda del caso.

Break.

Istruzione che interrompe il ciclo più esterno.

Radice.

La radice è la cartella che contiene tutte le altre cartelle. La cartella radice si indica con ‘/ ‘.

File System.

Struttura ad albero di file e di cartelle.

Operatore di selezione “?”.

L’operatore “?” è un operatore ternario ed è costituito da tre operandi: il primo è una condizione logica e il valore di questa espressione può essere il secondo operando se la condizione è vera altrimenti l’espressione vale il terzo operando.
Sintassi:
condizione ? valore1 : valore2

Esecuzione di un applicazione.

E’ l’esecuzione del metodo static void main (String args[ ]), il quale porta ad eseguire altre cose e tutto il thread che segue l’applicazione.

Alcuni metodi principali (in generale).

static void main(String args[ ]).

Questo è il metodo che viene fatto eseguire quando io chiedo di eseguire una classe. Questo, ha come unico parametro una matrice di stringhe.

Object getSource( ).

Questo è un metodo di ActionEvent  e ritorna l’oggetto che ha generato l’evento.

void actionPerfomed(ActionEvent evento).

Questo è l’unico metodo dell’interfaccia ActionListener. ActionPerfomed viene richiamato dall’oggetto quando avviene l’evento.

int min(int a, int b).

Questo è un metodo della classe Math che ritorna il minimo fra i due valori.

double random( ).

Questo è un metodo della classe Math e restituisce dei valori compresi tra 0 (escluso) e 1 (compreso).

int indexOf(String str, int fromIndex).

Questo è un metodo della classe String che riceve come parametro una stringa e ritorna l’indice della prima occorrenza della stringa passata nella stringa su cui è applicata.

char charAt(int index).

Questo è un metodo della classe String che ritorna il carattere i-esimo della stringa.

int length( ).

Questo è un metodo della classe String che ritorna il numero di caratteri presenti nella stringa.

ESEMPI DI PROGRAMMAZIONE IN JAVA.

Classe Calcola.

Scopo programma: realizzare una calcolatrice che permetta di effettuare dei semplici calcoli.

import java.applet.* ;
import java.awt.event.* ;
import java.awt.* ;
public class Calcola extends Applet implements ActionListener
{
Button b[15] ;  //dichiaro una matrice di bottoni dentro alla quale metto i bottoni
int prossimaOp = 10 ;
Label lab ;
String op[ ] = {« + », « - « , « *  », » / »} ;
int val = 0 ; 
boolean azzera = true ;   //variabile che dice se si deve azzerare lo schermo della calcolatrice
public void init( )       // inizializza gli elementi dell’interfaccia
{
setLayout(new BorderLayout( )) ;
lab = new Label( “ “) ;
add(lab,BorderLayout.NORTH) ;  // inserisco la label a nord
Panel p = new Panel( ) ;
p.setLayout(new GridLayout(5,3)) ;  //do il layout al panel ‘p’
for(int i = 0 ; i < 10 ; i + +)
{
b[i] = new Button(“ “+ i) ;    //creo i primi dieci bottoni
p.add(b[i]) ;
b[i].addActionListener(this) ;
}
for(int i = 0 ; i < 5 ; i + +)
{
b[i+10] = new Button(op[i]) ;  //creo i rimanenti cinque bottoni
p.add(b[i+10]) ;
b[i+10].addActionListener(this) ;
}
}
public void actionPerformed(ActionEvent e)
// questo metodo viene richiamato dall’oggetto quando avviene l’evento
{
for(int i = 0 ; i < 15 ; i + +)
{
if(e.getSource( ) = = b[i])
break ;
if( i < 10)
{
if(azzera)
{
lab.setText(“ ”) ;
azzera = false ;
}
lab.setText(lab.getText( ) + i) ; /*scrivo il numero corrispondente al bottone schiacciato senza cancellare il numero precedente*/
}
else
{
switch(prossimaOp)
{
case 10 :
val = val + visore( ) ;
break ;
case 11 :
val = val * visore( ) ;
break ;
case 12 :
val = val - visore( ) ;
break ;
case 13 :
val = val / visore( ) ;
break ;
}
prossimaOp = i ;
lab.setText(“ “ + val) ;
azzera = true ;
if(i = = 14)
{
val = 0 ;
prossimaOp = 10 ;
}
}
}
int visore( )   //metodo che prende il numero digitato nella label dall’utente
{
int ris = 0 ;
try
{
ris = Integer.parseInt(lab.getText( )) ;
}
catch(NumberFormatException nfe)
{
}
}
}

Classe Radice.

Scopo programma: realizzare un applicazione che stampa i nomi e la dimensione di tutte le cartelle o sotto-cartelle che sono presenti dentro una radice o dentro una cartella che viene indicata come argomento.

import java.io.* ;
public class Radice
{
public static void main(String args[ ])
{
File radice = new File(“ / ”) ;    //creo la cartella radice
stampaFiles(radice) ;      //stampo i file della cartella indicata
}
public void stampaFiles(File f)   //metodo che mi consente di stampare i nomi e la dimensione delle cartelle
{
File contenuti[ ] ;   //matrice di file
System.out.println(“ ”+f) ;
if(f.isDirectory( ))    //guardo se il file è una cartella
{
contenuti = f.listFile( ) ;
for(int i = 0 ; i < contenuti.length ; i + +)
stampaFiles(contenuti[i]) ;
}
System.out.println(“ “+f.length( )) ; 
}
}

Classe Quiz.

Scopo programma: realizzare un’applicazione che permetta all’utente di giocare ad un quiz. Essa deve presentare una serie di domande e di risposte su due diverse colonne. Le domande si evidenzieranno una alla volta e l’utente a seconda della domanda evidenziata dovrà selezionare la risposta corretta. Se la risposta è corretta la domanda diventa verde altrimenti rossa.

import java.awt.event.* ;
import java.awt.* ;
import java.applet.* ;
public class Quiz extends Applet implements ActionListener
{
Label domande[ ] ;
Button risposte[ ] ;
String eticRisp[ ] = {“Italia”,”Spagna”,”Francia”,”Germania”,”Russia”} ;   //etichette dei bottoni
String eticDom[ ] = {“Roma”,”Madrid”,”Parigi”,”Berlino”,”Mosca”} ;    //etichette delle risposte
int evid = 0 ;   //variabile che indica la domanda evidenziata
int nd ;    //numero di domande
public void init( )     //metodo che inizializza gli elementi dell’interfaccia
{
nd = Math.min(eticDom.length, eticRisp.length) ;  //mi calcolo il numero di domande
setLayout(new GridLayout(nd, 2) ;   //impongo il layout dell’applicazione
risposte = new Button[nd] ;
domande = new Label[nd] ;
for(int i = 0 ; i < nd ; i + +)
{
risposte[i] = new Button(eticRisp[i]) ;
domande[i] = new Label(eticDom[i]) ;
risposte[i].addActionListener(this) ;
}
for(int i = 0 ; i < 100 ; i + +)
{
int cas1 = (int)(Math.random( )*nd) ;   //creo un numero casuale
int cas2 = (int)(Math.random( )*nd) ;
Button temp = risposte[cas1] ;
risposte[cas1] = risposte[cas2] ;  //in questa maniera effettuo il mescolamento
risposte[cas2] = temp ;
}
for(int i = 0 ; i < nd ; i + +)   //aggiungo i pulsanti solo dopo averli mescolati
{
add(risposte[i]) ;
add(domande[i]) ;
}
domande[evid].setBackground(Color.yellow) ;  //evidenzio la prima domanda
}
public void actionPerformed(ActionEvent evento)
//questo metodo viene richiamato dall’oggetto quando avviene l’evento
{
int cliccato = 0 ;                  //indice che utilizzerò per dire qual è il bottone schiacciato
while(evento.getSource( ) ! = risposte[cliccato])
cliccato + + ;   
if(risposte[cliccato].getLabel( ).equals(eticRisp[evid])
domande[evid].setBackground(Color.green) ;   //se la risposta è giusta la domanda diventa verde altrimenti rossa
else
domande[evid].setBackground(Color.red) ;
if(evid < nd)
evid + + ;
else
evid = 0 ;
domande[evid].setBackground(Color.yellow) ;
}
}

Classi Dado e Poker.

Scopo programma: realizzare un applicazione che presenti cinque dadi (bottoni). Ogni volta che l’utente schiaccia un dado questo deve cambiare il proprio valore con un numero compreso tra uno e sei, mentre in una zona apposita deve finirci la somma dei valori assunti da tutti cinque i dadi.

 

Classe Dado.

Descrizione classe: questa classe viene vista come un bottone ed è la classe che gestisce la mutazione del valore del pulsante ogni volta che questo viene cliccato.

import java.awt.event.* ;
import java.awt.* ;
public class Dado extends Button implements ActionListener
{
int v ;   //il valore che sarà visualizzato sul dado (bottone)
public Dado( )       //costruisce un nuovo dado
{
super( ) ;
addActionListener(this) ;   //lui stesso ascolterà ciò che gli succede
}
public void actionPerformed(ActionEvent evento)
//questo metodo viene richiamato dall’oggetto quando avviene l’evento
{
v = (int)Math.random( )*6 +1 ;  //creo un numero casuale tra uno e sei
setLabel(“ ”+v) ; 
}
public int getValore( )  //metodo che prende il valore
{
return v ;
}
}

Classe Poker.

Descrizione classe: in questa classe c’è tutto quello che permette all’utente di poter provare le funzionalità dell’applicazione.

import java.awt.event.* ;
import java.awt.* ;
import java.applet.* ;

public class Poker extends Applet implements ActionListener
{
Dado dadi[ ] = new Dado[5] ;  //dichiaro una matrice di cinque dadi.
Label risultati ;
public void init( )         //metodo che inizializza gli elementi dell’interfaccia
{
for(int i = 0 ; i < 5 ; i++)
{
dadi[i] = new Dado( ) ;  
add(dadi[i]) ;         //aggiungo i dadi
dadi[i].addActionListener(this) ;
}
risultati = new Label(“ ”) ;    //creo la label ‘risultati’
add(risultati) ;       //aggiungo la label
}
public void actionPerformed(ActionEvent evento)
//questo metodo viene richiamato dall’oggetto quando avviene l’evento
{
int somma = 0 ;
for(int i = 0 ; i < 5 ; i++)
somma + = dadi[i].getValore( ) ; //effettuo la somma per tutti i cinque dadi
risultati.setText(“ “+somma) ;   //la scrivo nella label
}
}

Metodo int nOccorenze(String file,String stringa[ ]).

Scopo programma: scrivere un metodo che legga il contenuto di un file di testo e  deve restituire il numero di volte che c’è nel file la stringa indicata.

public int nOccorrenze(String file, String stringa[ ])
{
FileReader fr ;    //permette di leggere un file di testo
int nelementi = 0 ;   //indica il n° di volte che si trova nel file la stringa indicata
String cont =   ;
try
{
fr = new FileReader(file) ;
}
catch(IOExecepton ioe)
{
System.out.println(“File non trovato”) ;
}
while(fr.ready( ))      //leggo finché c’è qualcosa da leggere sul file
{
cont + = fr.read( ) ;   //concateno la stringa letta con la stringa vuota
}
fr.close( ) ;
//confronto la stringa del file con la stringa indicata
for(int iniz = 0 ; (iniz = cont.indexOf(stringa, iniz)+1) ! = -1) ; iniz + +)  
nelementi ++ ;
return nelementi ;
}

Classe  StringTable.

Scopo programma: realizzare un applicazione che permetta di caricare un file binario e di salvarlo.

import java.util.* ;
import java.io.* ;
public class StringTable
{
String [ ][ ] mat ;                       //matrice bidimensionale
public void loadStream(InputStream is, char sep)
//questo metodo permette di caricare un file
{
BufferedReader br = new BufferedReader(new InputStreamReader(is)) ;
Vector lines = new Vector( ) ;   //creo un vettore
try   //provo ad eseguire le istruzioni
{
String s ;
for ( ;br.ready( ) && (s = br.readLine( )) ! = null ; )
lines.addElement(s) ;  //aggiungo al vettore la stringa s
}
catch (IOException ioe)   //acchiappo l’eccezione  di input/output
{
}
//creo la matrice bidimensionale con il numero di elementi presenti nel vettore
mat = new String[lines.size( )][ ] ;
for (int i = 0 ; i < mat.length ; i + +)
{
String li = (String)(lines.elementAt(i)) ;     //dichiaro una stringa a cui assegno l’elemento preso dal vettore
System.out.println(“”+ i + ”<”+ li + ”>”) ;
StringTokenizer st = new StringTokenizer(li, ” ”+ sep) ;  //tokenizzo la stringa
int k = 0 ;
try
{
k = Integer.parseInt(st.nextToken( ))-1 ;
//guardo se k è minore di 0 oppure se è maggiore o uguale al numero di elementi del vettore
if (k<0 || k> = lines.size( ))  
k = 0 ;
}
catch (NumberFormatException nfe)
{
k = 0 ;
}
//assegno alla matrice mat un numero di token ottenuti in seguito alla tokenizzazione
mat[k]=new String[st.countTokens( )] ;   
for (int j = 0 ; j < mat[i].length ; i+ +)
{
mat[k][j] = st.nextToken( ) ;
}
}
try
{
br.close( ) ;
}
catch (IOException ioe)
{
}
}
public void saveStream(OutputStream os, char sep)
//questo metodo permette di salvare un file
{
PrintStream ps = new PrintStream(os) ;
for (int i = 0 ; i < mat.length ; i + +)
{
ps.print(“ ”+ (i+1)) ;
for (int j = 0 ; j< mat[i].length ; i + +)
{
//stampo sullo schermo un carattere più il contenuto della matrice all’indice i e j
ps.print(""+ sep+ mat[i][j]) ;  
}
ps.println( ) ;
}
ps.close( ) ;
}
public static void main(String a[ ])
//metodo che viene eseguito quando chiedo di eseguire una classe.
{
StringTable st = new StringTable( ) ;   //costruisco un oggetto della classe StringTable
try   //provo ad eseguire l’istruzione
{
FileInputStream fis = new FileInputStream(“records.txt”) ;
st.loadStream(fis, ‘, ‘) ;              //applico sull’istanza indicata il metodo che permette di caricare un file
st.saveStream(System.out, ‘-‘) ;   //applico sull’istanza indicata il metodo che permette di salvare un file
}
catch (IOException ioe)      //acchiappo l’eccezione di input/output
{
}
}
}

Classe Animazione.

Scopo programma: realizzare un applet che permetta ad un rettangolo di muoversi avanti ed indietro sullo schermo di questa. 

import java.applet.* ;
public class Animazione extends Applet implements Runnable
{
Thread t ;
int x1 = 0 ;    //coordinata che modificherò per fare spostare il rettangolo
public void paint(Graphics g)
//metodo che permette di disegnare un oggetto
{
g.drawRect(x1, 30, 10, 10) ;     //disegno il rettangolo con larghezza dieci e altezza dieci
g.setColor(Color.red) ;     //impongo il colore del rettangolo
}
public void run( )
//metodo dove c’è tutto quello che deve essere fatto durante la vita del thread
{
//faccio muovere il rettangolo fino alla larghezza massima dell’applet
for(int i = 0 ; i < getSize( ).width ; i + +)  
{
try
{
Thread.sleep(1000) ;   //interrompo il processo per un secondo
}
catch(InteruptedException ie)
{
}
x1 + + ;   //incremento la x del rettangolo
repaint( ) ;  //aggiorno l’immagine
}
}
public void init( )
//questo metodo inizializza gli elementi dell’interfaccia
{
t = new Thread(this) ;    //creo il thread
t.start( ) ;   //metto il thread nella coda dei processi pronti per l’esecuzione
}
}

Classe AnimazioneDue

Scopo programma: realizzare un applet che permetta ad un rettangolo di compiere una traiettoria circolare sullo schermo di questa.

public class AnimazioneDue extends Applet implements Runnable
{
Thread t ;
int w = getSize( ).width ;     //variabile che indica la larghezza dell’applet
int h = getSize( ).height ;       //variabile che indica l’altezza dell’applet
int r = (int)(Math.min(w/2,h/2)) ;  //calcolo il valore del raggio della circonferenza
int xrett = 0 ;
int yrett = 0 ;
public void paint(Graphics g)
//metodo che permette di disegnare un oggetto
{
g.drawRect(xrett, yrett, 50, 50) ;
}
public void run( )
//metodo dove c’è tutto quello che deve essere fatto durante la vita del thread
{
for(int i = 0 ; i < true ; i + +)
{
try
{
Thread.sleep(1000) ;
}
catch(InterruptedException ie)
{
break ;
}
//calcolo le coordinate di un punto appartenente alla circonferenza
xrett = r * Math.cos(i) + w/2 ;  
yrett = r * Math.sin(i) + w/2 ;
repaint( ) ;   //aggiorno l’immagine
}
}
public void init( )
//questo metodo inizializza gli elementi dell’interfaccia
{
t = new Thread(this) ;  //creo il thread
t.start( ) ;   //metto il thread nella coda dei processi pronti per l’esecuzione
}
}

 

Appunti di informatica
Java
Stream.
File (in generale).
Classe File.
InputStream.
SequenceInputStream.
BufferedInputStream.
BufferedOutputStream.
DataInputStream.
DataOutputStream.
FileInputStream.
FileOutputStream.
FileReader.
FiltrerStream.
StreamTokenizer.
RandomAccessFile.
Thread.
Modi per creare un thread.
Processo.
Metodo paint.
Graphics.
Alcuni metodi della classe Graphics.
Von Neumann.
Enumeration.
Nozioni generali.
Switch.
Break.
Radice.
File System.
Operatore di selezione “?”.
Esecuzione di un applicazione.
Alcuni metodi principali (in generale).
static void main(String args[ ]).
Object getSource( ).
void actionPerfomed(ActionEvent evento).
int min(int a, int b).
double random( ).
int indexOf(String str, int fromIndex).
char charAt(int index).
int length( ).
ESEMPI DI PROGRAMMAZIONE IN JAVA.
Classe Calcola.
Classe Radice.
Classe Quiz.
Classi Dado e Poker.
Classe Dado.
Classe Poker.
Metodo int nOccorenze(String file,String stringa[ ]).
Classe  StringTable.
Classe Animazione.
Classe AnimazioneDue

 

Reghitto Federico Cl 4B/I

 

 

 

Fonte: http://www.schenone.net/public/files/Appunti%20di%20informatica%204.doc

Sito web da visitare: http://www.schenone.net

Autore del testo: sopra indicato nel documento di origine

Il testo è di proprietà dei rispettivi autori che ringraziamo per l'opportunità che ci danno di far conoscere gratuitamente i loro testi per finalità illustrative e didattiche. Se siete gli autori del testo e siete interessati a richiedere la rimozione del testo o l'inserimento di altre informazioni inviateci un e-mail dopo le opportune verifiche soddisferemo la vostra richiesta nel più breve tempo possibile.

 

Appunti Java

 

 

I riassunti , gli appunti i testi contenuti nel nostro sito sono messi a disposizione gratuitamente con finalità illustrative didattiche, scientifiche, a carattere sociale, civile e culturale a tutti i possibili interessati secondo il concetto del fair use e con l' obiettivo del rispetto della direttiva europea 2001/29/CE e dell' art. 70 della legge 633/1941 sul diritto d'autore

Le informazioni di medicina e salute contenute nel sito sono di natura generale ed a scopo puramente divulgativo e per questo motivo non possono sostituire in alcun caso il consiglio di un medico (ovvero un soggetto abilitato legalmente alla professione).

 

Appunti Java

 

"Ciò che sappiamo è una goccia, ciò che ignoriamo un oceano!" Isaac Newton. Essendo impossibile tenere a mente l'enorme quantità di informazioni, l'importante è sapere dove ritrovare l'informazione quando questa serve. U. Eco

www.riassuntini.com dove ritrovare l'informazione quando questa serve

 

Argomenti

Termini d' uso, cookies e privacy

 

Contatti

Cerca nel sito

Appunti Java