JAVA e NetBeans_ver_1

A Cura di Claudio Beghetto
Pagina 1 di 59
a cura di Claudio Beghetto
SOMMARIO
JAVA......................................................................................................................................................................................... 4
CODICE JAVA da compilare e poi RUN ............................................................................................................................................................................................... 6
Ese1 ........................................................................................................................................................................................................................................................ 7
Ese2 ........................................................................................................................................................................................................................................................ 7
Ese3
Ese 3 bis ........................................................................................................................................................................................................................... 8
Ese4 ........................................................................................................................................................................................................................................................ 9
Ese5 ...................................................................................................................................................................................................................................................... 10
Ese 6 ..................................................................................................................................................................................................................................................... 11
Ese 7 ..................................................................................................................................................................................................................................................... 12
Ese 8 ..................................................................................................................................................................................................................................................... 14
Ese 9 ..................................................................................................................................................................................................................................................... 15
Ese 10 ................................................................................................................................................................................................................................................... 16
Ese 11 ................................................................................................................................................................................................................................................... 18
Ese 12 ................................................................................................................................................................................................................................................... 20
Ese 13 ................................................................................................................................................................................................................................................... 20
Ese 14 ................................................................................................................................................................................................................................................... 22
Ese 15 ................................................................................................................................................................................................................................................... 24
Ese 16 ................................................................................................................................................................................................................................................... 25
Ese 17 ................................................................................................................................................................................................................................................... 27
Ese 18 ................................................................................................................................................................................................................................................... 29
Ese 19 Thread1..................................................................................................................................................................................................................................... 31
Ese 20 Genera PWD............................................................................................................................................................................................................................. 34
Ese 21 Scrittura e lettura Ordinata da un File....................................................................................................................................................................................... 36
Ese 22 Ordinamento di un array di stringhe ......................................................................................................................................................................................... 40
Ese 23 Connessione ad un DB ............................................................................................................................................................................................................. 41
APPLET: ................................................................................................................................................................................................................................................. 44
Applet pippo......................................................................................................................................................................................................................................... 45
Applet MuoviRect ................................................................................................................................................................................................................................ 46
Applet lab2.class .................................................................................................................................................................................................................................. 47
Applet lab3.class .................................................................................................................................................................................................................................. 48
Applet Colors ....................................................................................................................................................................................................................................... 51
Pagina 2 di 59
a cura di Claudio Beghetto
Applet Temperature.............................................................................................................................................................................................................................. 53
Applet Orologio.................................................................................................................................................................................................................................... 55
Creare un Eseguibile con...................................................................................................................................................................................................................... 57
LIBRERIE............................................................................................................................................................................................................................................ 59
Pagina 3 di 59
a cura di Claudio Beghetto
JAVA
1° scaricare JDK e Netbeans 6.5: http://bits.netbean s.org/netbeans/6.5/community/latest/ml/
Ulteriori Info sull’ IDE : NetBeans IDE Java Quick Start Tutorial
Pagina 4 di 59
a cura di Claudio Beghetto
* Puoi aggiungere o rimuovere i pacchetti più tardi usando il gestore di plug-in dell'IDE (Strumenti | Plug-in).
Si richiedono Java 6 o Java 5 per l'installazione e l'esecuzione dei pacchetti PHP, Ruby e C/C++ di NetBeans Puoi scaricare l'ultima versione di Java
a java.com.
Il JDK 6 o JDK 5 sono richiesti per l'installazione ed esecuzione di Java SE, Java e di tutti i pacchetti di NetBeans. Puoi scaricare il JDK da solo
oppure scaricare l'ultimo JDK con il pacchetto Java SE di NetBeans IDE.
Puoi anche scaricare NetBeans IDE come parte del pacchetto degli strumenti Java EE 5 o il pacchetto MySQL con GlassFish.
Il codice sorgente di NetBeans e le costruzioni di oggetti binari (build) senza i runtime inclusi sono anche disponibili nel formato zip. Vedi anche
istruzioni su come costruire l''IDE dai sorgenti o le istruzioni di installazione.
2° Dopo l'installazione:
Pagina 5 di 59
a cura di Claudio Beghetto
Javaapplication1
CODICE JAVA da compilare e poi RUN
package javaapplication1;
/**
*
* @author Claudio Beghetto
*/
public class Main
{
/** Main e' salvato come Main.java
* @param args the command line arguments
*/
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
Pagina 6 di 59
a cura di Claudio Beghetto
Ese1
Ese 1b
package rettangolo;
import java.awt.Rectangle;
/**
*
* @author Claudio Beghetto
*/
public class Main
{
/**
* @param args the command line arguments
*/
public static void main(String[] args)
public class primo
{
public static void main(String[] args)
{
int i;
for(i=1;i<=5;i++)
{
System.out.println(" Capitolo --> "+ i );
}
}
}
{
Rectangle BoxCereali= new Rectangle(5,10,20,30);
BoxCereali.translate(10,250);
System.out.println(BoxCereali);
}
}
run:
java.awt.Rectangle[x=15,y=260,width=20,height=30]
BUILD SUCCESSFUL (total time: 0 seconds)
Ese2
package centesimi;
/**
*
* @author
*/
public class Main {
/**
*@
*/
public static void main(String[] args) {
int cent= 10;
double totale=cent * 0.50;
int euro=5;
totale+=euro*20;
System.out.print("Valore Totale= "+ totale);
}
}
run:
Valore Totale= 105.0
Pagina 7 di 59
a cura di Claudio Beghetto
Ese3
Ese 3 bis
public class NewClass
{
public static void main(String[] args)
{
final int PENNY_VALUE = 1; // final sono le costanti
final int NICKEL_VALUE = 5;
final int DIME_VALUE = 10;
final int QUARTER_VALUE = 25;
final int DOLLAR_VALUE = 100;
public class Main
{
int pennies = 8; // il portamonete contiene 8 penny,
int nickels = 0; // nessun nickel,
int dimes = 4; // quattro dime,
int quarters = 3; // e tre quarter
/**
* @param args the command line arguments
*/
public static void main(String[] args)
{
String firstName = "Claudio";
String middleName = "Kid";
String lastName = "Hello";
// calcola il valore totale in penny
// estrai le iniziali
int total = pennies * PENNY_VALUE
+ nickels * NICKEL_VALUE
+ dimes * DIME_VALUE
+ quarters * QUARTER_VALUE;
String initials = firstName.substring(0, 1)
+ middleName.substring(0, 1)
+ lastName.substring(0, 1);
// usa la divisione (/) fra integer per convertire
//i centesimi in dollari
// aggiungi l'età
int dollar = total / DOLLAR_VALUE;
int cents = total % DOLLAR_VALUE;
int age = 29; // l'età dell'utente
String password = initials.toLowerCase() + age;
System.out.print("Valore totale = ");
System.out.print(dollar);
System.out.print(" dollari e ");
System.out.print(cents);
System.out.println(" centesimi.");
}
}
run:
Valore totale = 1 dollari e 23 centesimi.
BUILD SUCCESSFUL (total time: 1 second)
Pagina 8 di 59
System.out.println("La tua password e' " +
password);
}
}
run:
La tua password e' ckh29
BUILD SUCCESSFUL (total time: 0 seconds)
a cura di Claudio Beghetto
Ese4
package denaro;
// Esempio per avere un INPUT
import java.io.InputStreamReader;
import java.io.BufferedReader ;
import java.io.IOException;
/**
*
* @author
*/
public class NewClass
{
public static void main(String[] args)
{
InputStreamReader reader = new InputStreamReader (System.in);
BufferedReader myInput = new BufferedReader (reader);
String str= new String();
try
{
System.out.println("Quanti EURO hai?");
str = myInput.readLine();
System.out.println ("Hai scritto: "+ str);
}
catch (IOException e)
{
System.out.println ("Si è verificato un errore: " + e);
System.exit(-1);
}
}
}
run:
Quanti EURO hai?
25
Hai scritto: 25
BUILD SUCCESSFUL (total time: 5 seconds)
Pagina 9 di 59
a cura di Claudio Beghetto
Ese5
public class NewClass2
{
public static void main(String[] args)
{
final double CENT = 0.01;
final double CENT5 = 0.05;
final double CENT10 = 0.1;
final double EURO = 10.00;
InputStreamReader reader = new InputStreamReader (System.in);
BufferedReader myInput = new BufferedReader (reader);
int k;
String str= new String();
try
{
System.out.println("Quanti EURO hai?");
str = myInput.readLine();
k = Integer.parseInt(str);
System.out.println ("Hai scritto: "+ k + " = "+ k * EURO);
}
catch (IOException e)
{
System.out.println ("Si è verificato un errore: " + e);
System.exit(-1);
}
}
}
run:
Quanti EURO hai?
9
Hai scritto: 9 = 90.0
BUILD SUCCESSFUL (total time: 4 seconds)
Pagina 10 di 59
a cura di Claudio Beghetto
Ese 6
package pwd;
public class BankAcc
{
public BankAcc() // Costruttore
{
balance = 0;
}
package pwd;
public class TestBank {
public static void main(String[] args)
{BankAcc account = new BankAcc(10000);
final double INTEREST_RATE = 5;
public BankAcc(double initialBalance)
{
balance = initialBalance;
}
public void deposit(double amount)
{
balance = balance + amount;
}
public void withdraw(double amount)
{
balance = balance - amount;
}
public double getBalance()
{
return balance;
}
double interest;
// calcola e somma gli interessi per un periodo
interest = account.getBalance() * INTEREST_RATE /
100;
account.deposit(interest);
System.out.println("Il saldo dopo 1 anno e' di € "
+ account.getBalance());
double acc=1000;
account.withdraw(acc);
System.out.println("Il saldo dopo 1 anno e dopo aver
prelevato e' di € " + account.getBalance());
// somma nuovamente gli interessi
interest = account.getBalance() * INTEREST_RATE /
100;
account.deposit(interest);
System.out.println("Il saldo dopo 2 anni e' di € "
+ account.getBalance());
}
private double balance;
}
}
run:
Il saldo dopo 1 anno e' di € 10500.0
Il saldo dopo 1 anno e dopo aver prelevato e' di € 9500.0
Il saldo dopo 2 anni e' di € 9975.0
BUILD SUCCESSFUL (total time: 2 seconds)
Pagina 11 di 59
a cura di Claudio Beghetto
Ese 7
// Scrittura su di un file delle caratteristiche del Sistema in uso nel PC utente
public class Sistema
{
public static void main(String[] arg)
{
// Cambio lo standard output, uso il file Sistema.txt
File outFile=new File("Sistema.txt");
FileOutputStream fw;
try {fw=new FileOutputStream(outFile) ;}
catch (IOException e)
{fw=null;};
PrintStream Output=new PrintStream(fw);
System.setOut(Output);
// Scrivo sul nuovo standard output:
// Tempo:
long tempo=System.currentTimeMillis();
System.out.println("Tempo in millisecondi: "+tempo);
long t1=tempo/1000;
System.out.println("Tempo in secondi: "+t1);
long sec=t1%60;
long t3=t1/60;
long min=t3%60;
long t4=t3/60;
System.out.println("Tempo in ore h"+t4+" m"+min+" s"+sec);
System.out.println("nE' il tempo passato dal 1/1/1970 ad ora.n");
// Proprietà del sistema:
System.out.println("nProprieta' del sistema:n");
String tmp;
System.out.println("ntJAVAn");
tmp=System.getProperty("java.version ");
System.out.println("Versione dell'ambiente di Java Runtime: "+tmp);
tmp=System.getProperty("java.vendor");
System.out.println("Distributore dell'ambiente di Java Runtime: "+tmp);
tmp=System.getProperty("java.vendor.url");
System.out.println("URL del distributore di Java: "+tmp);
tmp=System.getProperty("java.home");
System.out.println("Directory dove e' installato Java: "+tmp);
tmp=System.getProperty("java.vm.specification.version");
System.out.println("Versione delle specifiche della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.vm.specification.vendor");
System.out.println("Distributore delle specifiche della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.vm.specification.name");
System.out.println("Nome delle specifiche della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.vm.version");
System.out.println("Versione della implementazione della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.vm.vendor" );
System.out.println("Distributore della implementazione della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.vm.name");
System.out.println("Nome della implementazione della Java Virtual Machine: "+tmp);
tmp=System.getProperty("java.specification.version");
Pagina 12 di 59
a cura di Claudio Beghetto
System.out.println("Versione dell'ambiente di Java Runtime: "+tmp);
tmp=System.getProperty("java.specification.vendor");
System.out.println("Distributore dell'ambiente di Java Runtime Java Runtime: "+tmp);
tmp=System.getProperty("java.specification.name" );
System.out.println("Nome dell'ambiente di Java Runtime: "+tmp);
System.out.println("ntCLASSIn");
tmp=System.getProperty("java.class.version");
System.out.println("Versione delle classi di Java: "+tmp);
tmp=System.getProperty("java.class.path");
System.out.println("Pathname delle classi di Java: "+tmp);
System.out.println("ntSISTEMA OPERATIVOn");
tmp=System.getProperty("os.name");
System.out.println("Nome Sistema Operativo: "+tmp);
tmp=System.getProperty("os.arch");
System.out.println("Architettura del Sistema Operativo: "+tmp);
tmp=System.getProperty("os.version");
System.out.println("Versione del sistema Operativo: "+tmp);
tmp=System.getProperty("file.separator");
System.out.println("Separatore di File: "+tmp);
tmp=System.getProperty("path.separator");
System.out.println("Separatore di Pathname: "+tmp);
tmp=System.getProperty("line.separator");
System.out.println("New Line: "+tmp);
System.out.println("ntUTENTEn");
tmp=System.getProperty("user.name");
System.out.println("Account name dell'utente: "+tmp);
tmp=System.getProperty("user.home");
System.out.println("Home directory dell'utente: "+tmp);
tmp=System.getProperty("user.dir");
System.out.println("Working directory dell'utente: "+tmp);
}
}
Risultato sul file Sistema.txt
Tempo in millisecondi: 1245674420046
Tempo in secondi: 1245674420
Tempo in ore h346020 m40 s20
nE' il tempo passato dal 1/1/1970 ad ora.n
nProprieta' del sistema:n
ntJAVAn
Versione dell'ambiente di Java Runtime: null
Distributore dell'ambiente di Java Runtime: Sun Microsystems Inc.
URL del distributore di Java: http://java.sun.com/
Directory dove e' installato Java: C:\Programmi\Java\jdk1.6.0_13\jre
Versione delle specifiche della Java Virtual Machine: 1.0
Etc.etc.
Pagina 13 di 59
a cura di Claudio Beghetto
Ese 8
// legge all’interno del file indicato nell’URL
import java.net.URL;
import java.io.*;
public class LanciaForm{
public static void main(String[] args) throws Exception {
URL PF = new URL("http://www.protezione.info/Index.html");
BufferedReader in = new BufferedReader(
new InputStreamReader(
PF.openStream()));
String inputLine;
while ((inputLine = in.readLine()) != null)
System.out.println(inputLine);
in.close();
}
}
Risultato della pagina www.protezione.info:
run:
<HTML>
<HEAD>
<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
<TITLE>Index</TITLE>
</HEAd>
<center>
<BODY background=Index1_BK1_files/gradiente.gif>
<br>
etc…..
Pagina 14 di 59
a cura di Claudio Beghetto
Ese 9
import java.awt.*;
public class ContEBL extends Frame
{
Label l1=new Label("Etichetta a Nord",Label.CENTER);
Label l2=new Label("Etichetta a Sud",Label.CENTER);
Label l3=new Label("Etichetta a Est",Label.CENTER);
Label l4=new Label("Etichetta a Ovest",Label.CENTER);
Label l5=new Label("Etichetta al Centro",Label.CENTER);
public ContEBL()
{
// uso add, perchè il Frame è una estensione di Window, che a sua
// volta estende Container.
l1.setBackground(Color.BLUE);
l1.setForeground(Color.YELLOW);
l2.setBackground(Color.RED);
l2.setForeground(Color.YELLOW);
l3.setBackground(Color.green);
l3.setForeground(Color.BLUE);
l4.setBackground(Color.yellow);
l4.setForeground(Color.blue);
l5.setBackground(Color.white);
l5.setForeground(Color.blue);
setLayout(new BorderLayout());
add(l1,BorderLayout.NORTH);
add(l2,BorderLayout.SOUTH);
add(l3,BorderLayout.EAST);
add(l4,BorderLayout.WEST);
add(l5,BorderLayout.CENTER);
pack();
setVisible(true);
}
public static void main(String [] arg)
{
new ContEBL();
}
}
Pagina 15 di 59
a cura di Claudio Beghetto
Ese 10
//vettore classico
class Vett
{
static int NOME = 0;
static int COGNOME = 1;
static int PAPERINO=0;
static int GAMBA=1;
static int Q1=2;
static int Q2=3;
static int Q3=4;
static int CICCIO=5;
static int COMM=6;
static int TOPO=7;
static int PIPPO=8;
static int CANE=9;
static int PAPERA=10;
static int PAPERONE=11;
static String personaggi[][] = {
{"Paolino","Paperino"}, {"Pietro","Gambadilegno"},
{"QUI","Non Specificato"}, {"QUO","Non Specificato"},
{"QUA","Non Specificato"}, {"Ciccio","Di Nonna Papera"},
{"Non Specificato","Basettoni"}, {"Non Specificato","Topolino"},
{"Pippo","Non Specificato"}, {"Pluto","Non Specificato"},
{"Non Specificato","Paperina"}, {"Non Specificato","Paperone"},
};
public static void main(String [] a)
{
int PersonaggioTmp;
int Numero=1;
System.out.println ("Alcuni Personaggi della Walt Disney");
PersonaggioTmp=PAPERINO;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=GAMBA;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=Q1;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=Q2;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
Pagina 16 di 59
a cura di Claudio Beghetto
PersonaggioTmp=Q3;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=CICCIO;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=COMM;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=CANE;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=PIPPO;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=PAPERONE;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
Numero=Numero+1;
PersonaggioTmp=TOPO;
System.out.println("Numero:"+Numero+"\tNome:"+personaggi[PersonaggioTmp][NOME]+"
Cognome:"+personaggi[PersonaggioTmp][COGNOME]);
System.out.println("Ho contato "+Numero+" personaggi, ne erano molti di più!");
// Questo si che è davvero un programma inutile! L'autore.
}
}
run:
Alcuni Personaggi della Walt Disney
Numero:1
Nome:Paolino Cognome:Paperino
Numero:2
Nome:Pietro Cognome:Gambadilegno
Numero:3
Nome:QUI Cognome:Non Specificato
Numero:4
Nome:QUO Cognome:Non Specificato
Numero:5
Nome:QUA Cognome:Non Specificato
Numero:6
Nome:Ciccio Cognome:Di Nonna Papera
Numero:7
Nome:Non Specificato Cognome:Basettoni
Numero:8
Nome:Pluto Cognome:Non Specificato
Numero:9
Nome:Pippo Cognome:Non Specificato
Numero:10
Nome:Non Specificato Cognome:Paperone
Numero:11
Nome:Non Specificato Cognome:Topolino
Ho contato 11 personaggi, ne erano molti di più!
Pagina 17 di 59
a cura di Claudio Beghetto
Ese 11
import java.io.*;
import java.util.Calendar;
class libri
{
public int dataP;
public String Autore=new String();
int prezzo;
// costruttore
public libri(int annodiPubb, String Aut, int pz)
{
dataP=annodiPubb;
this.Autore=Aut;
prezzo=pz;
}
int eta;
// Funzione che calcola l'età ;
public int calcolaAnnoUscita ( int annoattuale )
{
eta= annoattuale - dataP ;
System.out.println("Il libro e' uscito da.." + eta + " anni - Autore : " + this.Autore);
return (eta);
}
public int calcolaPrezzo ( int pz )
{
int prezzoIvato;
prezzoIvato= (pz *20/100) +pz ;
System.out.println("Il prezzo del libro e' di.." + prezzoIvato + " euro con iva");
return (prezzoIvato);
}
public static void main (String[] args) throws IOException
{
//Definizione dello "standard input stream"
BufferedReader lettore = new BufferedReader(new InputStreamReader(System.in));
// crea due variabili chiamate "messaggio, Cogn" per l'input
String messaggio,Aut;
int pz;
//int cifra ;
System.out.print("Introduci il Titolo: ");
//azzera il buffer, prima del test di input
System.out.flush();
messaggio=lettore.readLine();
System.out.print("Il tuo libro ");
System.out.println("preferito e' : "+ messaggio);
System.out.println("Metti AnnoPubblicazione");
System.out.flush();
Pagina 18 di 59
a cura di Claudio Beghetto
int Data = Integer.parseInt(lettore.readLine());
System.out.println("Metti l'Autore");
System.out.flush();
Aut = lettore.readLine();
System.out.println("Metti il Prezzo in euro");
System.out.flush();
pz = Integer.parseInt(lettore.readLine());
libri Libro= new libri(Data,Aut,pz);
Libro.Autore=Aut;
Libro.prezzo=pz;
java.util.GregorianCalendar gc = new java.util.GregorianCalendar();
int anno = gc.get(gc.YEAR);
Libro.calcolaAnnoUscita(anno);
Libro.calcolaPrezzo(pz);
}
}
run:
Introduci il Titolo: JAVA E NETBEANS
Il tuo libro preferito e' : JAVA E NETBEANS
Metti AnnoPubblicazione
2008
Metti l'Autore
CLAUDIO
Metti il Prezzo in euro
20
Il libro e' uscito da..1 anni - Autore : CLAUDIO
Il prezzo del libro e' di..24 euro con iva
------------------------------------------------------------------------
Pagina 19 di 59
a cura di Claudio Beghetto
Ese 12
import java.util.Random;
public class Dice
{
public static void main(String[] args)
{
Random generator = new Random();
// getta il dado dieci volte
for (int i = 1; i <= 10; i++)
{
int d = 1 + generator.nextInt(6);
System.out.print(d + " ");
}
System.out.println();
}
}
run:
5463564521
Ese 13
public class Table2
{
public static void main(String[] args)
{
final int COLUMN_WIDTH = 10;
int[][] powers = new int[10][8];
for (int i = 0; i < 10; i++)
for (int j = 0; j < 8; j++)
powers[i][j] = (int)Math.pow(i + 1, j + 1);
printTable(powers, COLUMN_WIDTH);
}
/**
Stampa un array bidimensionale di valori double
@param table i valorida stampare
@param width la larghezza della colonna
*/
public static void printTable(int[][] table, int width)
{
for (int i = 0; i < table.length; i++)
{
for (int j = 0; j < table[i].length; j++)
{
System.out.print(format(table[i][j], width));
}
System.out.println();
}
}
/**
Formatta un numero intero in modo che si adatti
a un campo di larghezza costante
Pagina 20 di 59
a cura di Claudio Beghetto
@param n l'intero da formattare
@param width la largheza del campo
@return una stringa larga width, formata da spazi
iniziali seguiti dal numero n
*/
public static String format(int n, int width)
{
String nstr = "" + n;
// riempie con spazi
while (nstr.length() < width)
nstr = " " + nstr;
return nstr;
}
}
Run ( in realta’ la formattazione dei numeri e’ perfetta):
1
1
1
1
1
1
1
1
2
4
8
16
32
64
128
256
3
9
27
81
243
729 2187
6561
4
16
64
256 1024
4096 16384 65536
5
25
125
625
3125 15625 78125 390625
6
36
216 1296
7776 46656 279936 1679616
7
49
343 2401 16807 117649 823543 5764801
8
64
512 4096 32768 262144 2097152 16777216
9
81
729 6561 59049 531441 4782969 43046721
10
100
1000 10000 100000 1000000 10000000 100000000
Pagina 21 di 59
a cura di Claudio Beghetto
Ese 14
public class TreeTest
{ public static void main(String[] args)
{ Tree staff = new Tree();
staff.insert("Romeo");
staff.insert("Juliet");
staff.insert("Tom");
staff.insert("Dick");
staff.insert("Harry");
staff.print();
}
}
/**
Questa classe implementa un albero binario di ricerca i cui
nodi contengono oggetti che implementano l'interfaccia
Comparable.
*/
class Tree
{ /**
Costruisce un albero vuoto.
*/
public Tree()
{ root = null;
}
/**
Inserisce un nuovo nodo nell'albero.
@param obj l'oggetto da inserire
*/
public void insert(Comparable obj)
{ Node newNode = new Node();
newNode.data = obj;
newNode.left = null;
newNode.right = null;
if (root == null) root = newNode;
else root.insertNode(newNode);
}
/**
Stampa il contenuto dell'albero in successione ordinata.
*/
public void print()
{ if (root != null)
root.printNodes();
}
private Node root;
private class Node
{ /**
Inserisce un nuovo nodo come discendente di questo nodo.
Pagina 22 di 59
a cura di Claudio Beghetto
@param newNode il nodo da inserire
*/
public void insertNode(Node newNode)
{ if (newNode.data.compareTo(data) < 0)
{ if (left == null) left = newNode;
else left.insertNode(newNode);
}
else
{ if (right == null) right = newNode;
else right.insertNode(newNode);
}
}
/**
Stampa questo nodo e tutti i suoi discendenti
in successione ordinata.
*/
public void printNodes()
{ if (left != null)
left.printNodes();
System.out.println(data);
if (right != null)
right.printNodes();
}
public Comparable data;
public Node left;
public Node right;
}
}
run:
Dick
Harry
Juliet
Romeo
Tom
Pagina 23 di 59
staff.insert("Romeo");
staff.insert("Juliet");
staff.insert("Tom");
staff.insert("Dick");
staff.insert("Harry");
a cura di Claudio Beghetto
Ese 15
import java.io.*;
public class PrezziNuovi
{
public static void main(String[] args)throws IOException
{
int mioVettore[]=new int[10];
int mioVett[]=new int[10];
mioVett[0]=100;
mioVett[1]=200;
mioVett[2]=300;
mioVett[3]=400;
mioVett[4]=500;
mioVett[5]=600;
BufferedReader lettore = new BufferedReader(new InputStreamReader(System.in));
for(int i=0;i<=5;i++)
{
System.out.println("Metti i vecchi Prezzi, max. 1000");
System.out.flush();
int Cifra = Integer.parseInt(lettore.readLine());
mioVettore[i]=Cifra;
}
System.out.println("----------------------");
for(int i=0;i<=5;i++)
System.out.println(mioVettore[i]);
System.out.println("----------------------");
System.out.println("-------I nuovi prezzi sono ora------------");
for(int i=0;i<=5;i++)
System.out.println(mioVettore[i]+ mioVett[i]);
System.out.println("----------------------");
}
}
run:
Metti i vecchi Prezzi, max. 1000
100
Metti i vecchi Prezzi, max. 1000
200
Metti i vecchi Prezzi, max. 1000
300
Metti i vecchi Prezzi, max. 1000
400
Metti i vecchi Prezzi, max. 1000
500
Metti i vecchi Prezzi, max. 1000
600
----------------------
Pagina 24 di 59
100
200
300
400
500
600
-----------I nuovi prezzi sono ora-----------200
400
600
800
1000
1200
------
a cura di Claudio Beghetto
Ese 16
*
* Moto.java
*/
/**
* con Javadoc da qui si estraggono le informazioni sul programma,notare in alto
*i doppi asterischi
*Static sta ad intendersi come "Metodo di Classe", il compilatore non prende
in considerazione nessun oggetto nel main ( se non Moto1 e i suoi metodi) se
*le classi sono prive della parola chiave "static".
*String va scritto con la S maiuscola, e' una classe.
* @author clb
*/
public class Moto1
{
public void rumore()
{
System.out.println("BRRRRROWWWWWWW!");
}
public void cilindri(int n)
{
int c=n/2;
System.out.println(c);
}
static class Ducati extends Moto1
{
public void rumore()
{
System.out.println("UHMMMMMMMMMMMMRRRR!");
}
}
static class Bmw extends Moto1
{
public void rumore(String rum)
{
System.out.println(rum);
}
public void frecce()
{
System.out.println("bip..bip");
}
}
static class Aprilia extends Moto1
{
public void cilindri(int n)
{
System.out.println(n);
super.cilindri(n);
}
Pagina 25 di 59
a cura di Claudio Beghetto
}
static class Honda extends Moto1 { }
// utilizza tutti i metodi della superclasse Moto1
public static void main(String[] args)
{
String rumor="bopbup..buuup";
Moto1 mm0 =new Moto1.Ducati();
Moto1.Bmw mm1=new Moto1.Bmw();
Moto1 mm2=new Moto1.Honda();
Moto1 mm3=new Moto1.Aprilia();
mm0.rumore();
mm1.rumore(rumor);
mm1.frecce();
mm2.rumore();
mm3.cilindri(4);
} // fine Main
}//fine superclasse Moto1
run:
UHMMMMMMMMMMMMRRRR!
bopbup..buuup
bip..bip
BRRRRROWWWWWWW!
4
2
Pagina 26 di 59
a cura di Claudio Beghetto
Ese 17
import java.io.*;
import java.util.Calendar;
class studenti
{
public int annonascita;
public String Cognome=new String();
// costruttore
public studenti(int annodinascita, String Cognome)
{
annonascita=annodinascita;
this.Cognome=Cognome;
}
int eta;
// Funzione che calcola l'et� ;
public int calcolaeta ( int annoattuale )
{
eta= annoattuale - annonascita ;
System.out.println("Hai la bellezza di anni.." + eta + "-" + this.Cognome);
return (eta);
}
public static void main (String[] args)throws IOException
{
//Definizione dello "standard input stream"
BufferedReader lettore = new BufferedReader(new InputStreamReader(System.in));
// crea due variabili chiamate "messaggio, Cogn" per l'input
String messaggio,Cogn;
//int cifra ;
System.out.print("Introduci il messaggio: ");
//azzera il buffer, prima del test di input
System.out.flush();
messaggio=lettore.readLine();
System.out.print("Tu ");
System.out.println("hai scritto: "+ messaggio);
System.out.println("Metti AnnoNascita");
System.out.flush();
int Cifra = Integer.parseInt(lettore.readLine());
System.out.println("Metti il Cognome");
System.out.flush();
Cogn = lettore.readLine();
studenti Claudio= new studenti(Cifra,Cogn);
Claudio.Cognome=Cogn;
Pagina 27 di 59
a cura di Claudio Beghetto
java.util.GregorianCalendar gc = new java.util.GregorianCalendar();
int anno = gc.get(gc.YEAR);
Claudio.calcolaeta(anno);
}
}
run:
Introduci il messaggio: Ciao a TUTTI
Tu hai scritto: Ciao a TUTTI
Metti AnnoNascita
1980
Metti il Cognome
Bimbo
Hai la bellezza di anni..29-Bimbo
Pagina 28 di 59
a cura di Claudio Beghetto
Ese 18
//Scrivere una classe che simuli il lancio di un dado con sei facce.
*/
public class dado
{
//la classe dado non ha variabili di classe n� variabili di istanza
//esse non sono necessarie perch� un dado non deve avere "memoria" dei numeri che sono stati
estratti in precedenza
//Tale classe ha solo procedure
//
//per tale motivo non c'� alcun motivo di introdurre un costruttore esplicito della classe
//per usare la classe (purch� essa sia nella stessa directory di una altra classe o nel suo classpath)
//basta invocare il metodo dado.lancia()
//
//il comportamento � dunque simile a quello della classe Math
public static void main(String[] args)
{
//Il main � davvero semplice e serve solo a scopo di controllo
//per controllare se gli altri metodi della classe funzionano
//per questo motivo non prevede alcuna sofisticata interfaccia del tipo JOptionPane
//esso viene eseguito solo se la classe dado � chiamata direttamente con: java dado
//altrimenti non viene attivato e non � necessario alla funzionalit� dell'oggetto
System.out.println( "Lanciando il dado � uscita la faccia con il numero "+lancia());
}
public static int lancia()
{
// questo metodo simula il lancio vero e proprio
//lo dichiaro public per potere usare un vero dado
//quando user� questo programma come oggetto da altre classi
return (int)(Math.random()*6)+1;
}
}
Pagina 29 di 59
a cura di Claudio Beghetto
import javax.swing.JOptionPane;
public class esercizio_1_2
{
// i metodi di questa classe possono ridursi al solo main perch� tutte le operazioni sono state chiuse nella
classe dado
public static void main(String[] args)
{
//il main si limita a chiamare il metodo "gioco"
//che contiene tutto il meccanismo
//Perchè mettere tutto in un altro emtodo e non nel main?
//perch� cos� la classe sar� meglio utilizzabile per i successivi esercizi
gioco();
System.exit(0);
}
public static int gioco()
{
// Il metodo restituisce 1 se vince il giocatore, 0 se vince il computer
//poiché la classe dado non ha variabili di classe
//o variabili di istanza, non è necessario invocare per essa il metodo costruttore
// sufficiente chiamarla
//se dado.class nella stessa directory di esercizio_1_2 o visibile dal classpath
//essa fornir i servizi richiesti e cio il lancio del dado
int primoNumero=dado.lancia();
int secondoNumero=dado.lancia();
int terzoNumero=dado.lancia();
int totale=primoNumero+secondoNumero+terzoNumero;
//chiamo un metodo che gestisce l'output
notificaEsito(totale,primoNumero,secondoNumero,terzoNumero);
if (totale<=12) return 0;
else return 1;
}
public static void notificaEsito(int punteggio, int num1, int num2, int num3)
{
String esito;
if (punteggio<=12) esito="perso : (";
else esito="vinto : )";
//ed ecco la notifica
JOptionPane.showMessageDialog(null,
"Lanciando il primo dado è uscita la faccia \n con il numero "+num1+"\n"+
"Lanciando il secondo dado è uscita la faccia \n con il numero "+num2+"\n"+
"Lanciando il terzo dado è uscita la faccia \n con il numero "+num3+"\n"+
"Hai totalizzato "+punteggio+" punti e hai "+esito);
}
Pagina 30 di 59
}
a cura di Claudio Beghetto
Ese 19 Thread1
Come creare un Thread
Ci sono, fondamentalmente, due metodi per creare un thread in Java. Quello che ci sentiamo di consigliare,
soprattutto per la sua struttura Object Oriented, è basato sul seguente costruttore:
public Thread (Runnable target)
ovvero fa uso di un parametro di tipo Runnable, che costituisce la classe che si desidera esegua del codice in
modo indipendente dal processo che la manda in esecuzione. Runnable è un'interfaccia che contiene il
seguente metodo
void run()
che dovrà, pertanto, essere implementato dalla classe da "dare in pasto" al costruttore del thread. Vediamo un
esempio per chiarire meglio quanto detto:
Come si può osservare, il main() crea un'istanza r della classe SimpleRunner. Tale istanza avrà accesso ai
propri dati che, in questo caso, sono rappresentati semplicemente dalla variabile intera i. Poiché l'istanza r viene
passata al costruttore della classe Thread, si evince che la variabile i rappresenterà il dato sul quale opererà il
thread t quando andrà in esecuzione.
Ogni thread inizia sempre attraverso l'invocazione del metodo run() dell'istanza di tipo Runnable che il thread
stesso carica in fase di costruzione (nel nostro esempio r). Il metodo run(), a sua volta, viene invocato quando si
effettua una chiamata al metodo start() del thread.
Un ambiente di programmazione multithread consente di creare più thread basati sulla medesima istanza di tipo
Runnable.
public class SimpleThread
{
public static void main(String[] args)
{
SimpleRunner r = new SimpleRunner();
SimpleRunner2 r2 = new SimpleRunner2();
Thread t = new Thread(r);
t.setName("Mio Thread");
t.setPriority(8);
t.start();
System.out.println(t);
Thread t2 = new Thread(r2);
t2.setName("Thread2");
t.setPriority(3);
t2.start();
System.out.println(t2);
}
static class SimpleRunner implements Runnable
{
int i;
public void run()
Pagina 31 di 59
a cura di Claudio Beghetto
{
i = 0;
while (true)
{
System.out.println();
System.out.println("****** Sono nel Primo Thread ******" + i++);
if ( i == 20)
{
break;
}
}
}
}
static class SimpleRunner2 implements Runnable
{
int i2;
public void run()
{
i2 = 0;
while (true)
{
System.out.println();
System.out.println("+++++ Sono nel secondo Thread ++++" + i2++);
if ( i2 == 20)
{
// System.out.println(i+i2);
break;
}
}
}
}
}
run:
Thread[Mio Thread,8,main]
Thread[Thread2,5,main]
+++++ Sono nel secondo Thread ++++0
+++++ Sono nel secondo Thread ++++1
+++++ Sono nel secondo Thread ++++2
+++++ Sono nel secondo Thread ++++3
+++++ Sono nel secondo Thread ++++4
+++++ Sono nel secondo Thread ++++5
+++++ Sono nel secondo Thread ++++6
+++++ Sono nel secondo Thread ++++7
+++++ Sono nel secondo Thread ++++8
+++++ Sono nel secondo Thread ++++9
Pagina 32 di 59
a cura di Claudio Beghetto
+++++ Sono nel secondo Thread ++++10
+++++ Sono nel secondo Thread ++++11
+++++ Sono nel secondo Thread ++++12
****** Sono nel Primo Thread ******0
****** Sono nel Primo Thread ******1
****** Sono nel Primo Thread ******2
****** Sono nel Primo Thread ******3
****** Sono nel Primo Thread ******4
****** Sono nel Primo Thread ******5
****** Sono nel Primo Thread ******6
****** Sono nel Primo Thread ******7
+++++ Sono nel secondo Thread ++++13
+++++ Sono nel secondo Thread ++++14
+++++ Sono nel secondo Thread ++++15
+++++ Sono nel secondo Thread ++++16
+++++ Sono nel secondo Thread ++++17
+++++ Sono nel secondo Thread ++++18
+++++ Sono nel secondo Thread ++++19
****** Sono nel Primo Thread ******8
****** Sono nel Primo Thread ******9
****** Sono nel Primo Thread ******10
****** Sono nel Primo Thread ******11
****** Sono nel Primo Thread ******12
****** Sono nel Primo Thread ******13
****** Sono nel Primo Thread ******14
****** Sono nel Primo Thread ******15
****** Sono nel Primo Thread ******16
****** Sono nel Primo Thread ******17
****** Sono nel Primo Thread ******18
****** Sono nel Primo Thread ******19
Pagina 33 di 59
a cura di Claudio Beghetto
Ese 20 Genera PWD
package pwd;
import javax.swing.JOptionPane;
/**
*
* @author Claudio Beghetto
*/
public class CreaPWD
{
public static void main(String[] args)
{
GenNum g = new GenNum();
GenPwd gp=new GenPwd();
JOptionPane.showMessageDialog(null, "Ciao, Genero le Password" );
for(int i=1;i<=5;i++)
{
//g.stampa();
gp.stampaPwd();
}
}
static class GenNum
{
void stampa()
{
int n=genera();
// allineo numero a dx.
if(n<100)
System.out.print(" ");
if(n<10)
System.out.print("");
System.out.println(n);
}
int genera()
{
return genera(100);
}
int genera(int range)
{
double d=Math.random() * range +1;
return (int)d;
}
int genera(boolean negativo)
{
if (negativo)
return - genera();
else
return genera();
}
}
static class GenPwd extends GenNum
Pagina 34 di 59
a cura di Claudio Beghetto
{
void stampaPwd()
{
System.out.println("--> "+ generaPWD());
}
String generaPWD()
{
String pwd="";
double d=Math.random() * 100 +1;
for(int i=1;i<=6;i++)
{
pwd +=generaCaratteri();
}
String p=pwd +(int)d;
return p;
}
char generaCaratteri()
{
final int codPrimaLettera='a';
final int codUltimaLettera='z'-'a'+1;
int i=codPrimaLettera+(genera(codUltimaLettera))+1;
return (char)i;
}
}
}/*
run:
--> pdssju26
--> eg{lpn17
--> hmlxiu80
--> ftxcol31
--> {rspyu78
*/
Pagina 35 di 59
a cura di Claudio Beghetto
Ese 21 Scrittura e lettura Ordinata da un File
package pwd;
import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.logging.Level;
import java.util.logging.Logger;
class file
{
RandomAccessFile _File;
String Url = "Dati.txt";
// Metodo per l'apertura o la creazione del file.
public void Apertura (String Metodo)
{
try
{
_File = new RandomAccessFile(Url, Metodo);
}catch (IOException e)
{
System.out.println("Problema nell'apertura del file.");
}
}
// Metodo di scrittura all'interno del file.
public String Scrittura (String dato)
{
try {
long Dim = _File.length();
_File.seek(Dim);
_File.writeBytes(dato);
}catch (IOException e)
{
System.out.println("Problema nella scrittura sul file."); }
return dato;
}
void Chiusura()
{
try
{
_File.close();
}
catch (IOException e)
{
System.out.println("Problema nella chiusura del file.");
}
}
}
Pagina 36 di 59
a cura di Claudio Beghetto
// Metodo per l'ordinamento dei dati nel file.
class SortFile
{
public SortedSet set = new TreeSet();
SortFile()
{
// Creo una lista ordinata
// Leggo il file
try
{
BufferedReader in = new BufferedReader(new FileReader("Dati.txt"));
String str;
while ((str = in.readLine()) != null) {
// Aggiungo la riga alla lista
set.add(str);
set.comparator();
str.compareTo(str);
}
in.close();
} catch (IOException e)
{
}
// Iterazione degli elementi della lista
Iterator it = set.iterator();
while (it.hasNext())
{
// Ottengo e stampo gli elementi
Object element = it.next();
System.out.println(element);
}
}
}
class dato
{
long Dim_random = 25;
String Cognome, Nome;
char Sesso;
int Et=1;
// Metodo nuovo.
public void Nuovo(String cognome, char sesso, int et)
{
this.Cognome = cognome; //this.Nome = nome;
this.Sesso = sesso;
this.Et = et;
}
// Medoto per la concatenazione della stringa.
public String Unione (String cognome, char sesso, int et)
{
String Concatenata = cognome + ";" + sesso + ";" + et+"\n";
return Concatenata;
}
Pagina 37 di 59
a cura di Claudio Beghetto
// Metodo per ridimensionare la stringa secondo una dimensione random.
public String Ridimensiona (String dato)
{
int i, dim = dato.length();
for (i = dim; i < Dim_random; i++)
dato+="*";
return dato;
}
}
public class ordinafile
{
// Metodo main.
public static void main(String[] args)
{
String cognome="",sesso_temp="";
char sesso;
int et=1, ripeti = 1;
Scanner Tast = new Scanner(System.in);
file obj = new file();
dato obj1 = new dato();
BufferedReader lettore = new BufferedReader(new InputStreamReader(System.in));
while (ripeti != 0)
{
try {
System.out.print("Cognome: \n");
System.out.flush();
cognome = lettore.readLine();
System.out.print("Sesso: \n");
System.out.flush();
sesso_temp = lettore.readLine();
System.out.print("Età: \n");
System.out.flush();
et =Integer.parseInt(lettore.readLine());
} catch (IOException ex) {
Logger.getLogger(ordinafile.class.getName()).log(Level.SEVERE, null, ex);
}
//cognome = Tast.nextLine();
//System.out.print("Nome: \n");
nome = Tast.nextLine();
//System.out.print("Sesso: \n"); sesso_temp = Tast.nextLine();
//System.out.print("Età: \n");
et = Tast.nextInt();
sesso = sesso_temp.charAt(0);
obj1.Nuovo(cognome, sesso, et);
String Stringa = obj1.Unione(cognome, sesso, et);
obj1.Ridimensiona(Stringa);
obj.Apertura("rwd");
obj.Scrittura(Stringa);
obj.Chiusura();
System.out.println("1 = Continua l'inserimento; 0 = Ferma e visualizza tutto:");
ripeti = Tast.nextInt();
}
SortFile sort=new SortFile();
}
}
Pagina 38 di 59
a cura di Claudio Beghetto
run:
Cognome:
Bianchi
Sesso:
M
Età:
25
1 = Continua l'inserimento; 0 = Ferma e visualizza tutto:
1
Cognome:
Belli
Sesso:
F
Età:
18
1 = Continua l'inserimento; 0 = Ferma e visualizza tutto:
1
Cognome:
Rossi
Sesso:
M
Età:
35
1 = Continua l'inserimento; 0 = Ferma e visualizza tutto:
0
Belli;F;18
Bianchi;M;25
Rossi;M;35
Pagina 39 di 59
a cura di Claudio Beghetto
Ese 22 Ordinamento di un array di stringhe
package pwd;
/**
*
* @author Claudio Beghetto
*/
public class SortString
{
// A bubble sort for Strings.
static String arr[] =
{
"ieri", "thè", "tempo", "fine", "aglio", "giallo", "mento",
"troppo", "come", "topo", "taglio", "albero", "oro", "raso", "città"
};
public static void main(String args[])
{
for(int j = 0; j < arr.length; j++)
{
System.out.println("Prima.."+arr[j]);
}
for(int j = 0; j < arr.length; j++)
{
for(int i = j + 1; i < arr.length; i++)
{
if(arr[i].compareTo(arr[j]) < 0)
{
String t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
System.out.println("ORA.." + arr[j]);
}
}
}
Pagina 40 di 59
a cura di Claudio Beghetto
Ese 23 Connessione ad un DB
import java.sql.*;
public class Conn2
{
private static Connection con;
private static Statement st;
private static ResultSet rs;
private static int nomeCol;
private static int ruoloCol;
public static void main(String arg[])
{
try
{
// aggancio il driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch(ClassNotFoundException e)
{
System.out.println("Driver non trovato");
System.exit(0);
}
try
{
// mi connetto al DB Squadre tramite il driver jdbc:odbc <
String dbURL = "jdbc:odbc:squadre";
// gli passiamo jdbc:odbc:squadre
con = DriverManager.getConnection(dbURL);
}
catch(SQLException sql)
{
System.out.println("Errore connessione");
System.exit(0);
}
Pagina 41 di 59
a cura di Claudio Beghetto
try
{
// avviso che sto creando un recordset
st = con.createStatement();
}
catch(SQLException s)
{
System.out.println("Errore creazione Recordset");
}
try
{
// Query di selezione
rs = st.executeQuery("SELECT Nome,Ruolo FROM Giocatori ORDER BY Nome");
}
catch(SQLException esql)
{
System.out.println("Errore esecuzione Query");
}
try
{
// individuo numericamente la colonna della tabella che
// m'interessa Nome e Ruolo tabella Giocatori
nomeCol = rs.findColumn("Nome");
ruoloCol = rs.findColumn("Ruolo");
}
catch(SQLException a)
{
System.out.println("Errore ricerca colonne");
}
try
{
while(rs.next())
System.out.println(rs.getString(nomeCol)+ " - "+ rs.getString(ruoloCol));
}
catch(SQLException as)
{
System.out.println("Errore selezione dati");
}
try
{
// quando ho finito chiudo prima il recordset
// poi la connessione
st.close();
con.close();
}
catch(SQLException ad)
{
System.out.println("Errore chiusura DataBase");
}
}
}
Pagina 42 di 59
a cura di Claudio Beghetto
run:
Buffon - Portiere
Del Piero - Attaccante
Gattuso - Libero
Gilardino - Attaccante
Ibra - Attaccante
Kaka - Attaccante
Maldini - Difensore
Materazzi - Difensore
Montella - Attaccante
Totti - Attaccante
Pagina 43 di 59
a cura di Claudio Beghetto
APPLET:
New Project
New File: pippo
Pagina 44 di 59
a cura di Claudio Beghetto
Applet pippo
import java.awt.*;
import java.applet.*;
/*
<applet code="pippo width=200 height=60>
</applet>
*/
public class pippo extends Applet {
public void paint(Graphics g)
{
g.drawString("Un'applet di prova", 20, 20);
}
}
Pagina 45 di 59
a cura di Claudio Beghetto
Applet MuoviRect
import
import
import
import
java.applet.Applet;
java.awt.Graphics;
java.awt.Graphics2D;
java.awt.Rectangle;
public class MuoviRect extends Applet
{
{
public void paint(Graphics g)
// ristabilisci il riferimento a Graphics2D
Graphics2D g2 =(Graphics2D) g;
// costruisci un rettangolo e disegnalo
Rectangle cerealBox = new Rectangle(50, 50, 20, 30);
g2.draw(cerealBox);
// sposta il rettangolo orizzontalmente di 35 unità, e in basso di 25 unità
cerealBox.translate(35, 25);
// disegna il rettangolo nella nuova posizione
g2.draw (cerealBox);
g2.fill(cerealBox);
}
}
Pagina 46 di 59
a cura di Claudio Beghetto
Applet lab2.class
*
* @ */
import java.applet.*;
import java.awt.Graphics;
import java.awt.Color;
public class lab2 extends
Applet
{
StringBuffer buffer;
public void init() {
buffer = new
StringBuffer();
addItem("inizializzo...
");
}
public void destroy() {
addItem("preparo per
unloading...");
}
void addItem(String
newWord) {
System.out.println(newWord);
buffer.append(newWord);
repaint();
}
public void paint (Graphics g)
{
g.setColor(Color.LIGHT_GRAY
);
public void start() {
addItem("start... ");
}
Finestra di Output
g.fillRect(10,30,300,50);
g.setColor(Color.yellow)
public void stop() {
addItem("stop... ");
}
;
g.drawRect(10,
30, 300, 50);
g.drawString("Ciao, sono
Claudio e questa e' la mia
prima applet.",20,50);
}
}
Pagina 47 di 59
a cura di Claudio Beghetto
Applet lab3.class
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class lab3 extends Applet {
int luce = 0;
// 0 luci spente, 1 rosso
// 2 giallo, 3 verde
int yRosso=20;
int yGiallo=50;
int yVerde=80;
int ySpegni=120;
Button pulsanteRosso;
Button pulsanteGiallo;
Button pulsanteVerde;
Button pulsanteSpegni;
public void init()
{
setLayout(null);
pulsanteRosso = new Button("Rosso");
pulsanteRosso.setBounds(20, yRosso, 80, 20);
pulsanteGiallo = new Button("Giallo");
pulsanteGiallo.setBounds(20, yGiallo, 80, 20);
pulsanteVerde = new Button("Verde");
pulsanteVerde.setBounds(20, yVerde, 80, 20);
pulsanteSpegni = new Button("Spegni");
pulsanteSpegni.setBounds (40, ySpegni, 80, 20);
add(pulsanteRosso);
add(pulsanteGiallo);
add(pulsanteVerde);
add(pulsanteSpegni);
ActionListener al = new ActionListener()
Pagina 48 di 59
a cura di Claudio Beghetto
{
public void actionPerformed(ActionEvent evento)
{
Object s = evento.getSource();
if (s == pulsanteRosso)
Rosso();
else if (s == pulsanteGiallo)
Giallo();
else if (s == pulsanteVerde)
Verde();
else if (s == pulsanteSpegni)
Spegni();
}
};
pulsanteRosso.addActionListener(al);
pulsanteGiallo.addActionListener(al);
pulsanteVerde.addActionListener(al);
pulsanteSpegni.addActionListener(al);
}
void Rosso() {
luce = 1;
repaint();
}
void Giallo() {
luce = 2;
repaint();
}
void Verde() {
luce = 3;
repaint();
}
void Spegni(){
luce = 0;
repaint();
}
public void paint(Graphics g)
{
g.setColor(Color.gray);
g.fillRect(110, yRosso-10, 40, 100);
Pagina 49 di 59
a cura di Claudio Beghetto
switch (luce)
{
case 1:
g.setColor(Color.red);
g.fillOval(120, yRosso, 20, 20);
g.setColor(Color.black);
g.fillOval(120, yGiallo, 20, 20);
g.fillOval(120, yVerde, 20, 20);
break;
case 2:
g.setColor(Color.yellow);
g.fillOval(120, yGiallo, 20, 20);
g.setColor(Color.black);
g.fillOval(120, yRosso, 20, 20);
g.fillOval(120, yVerde, 20, 20);
break;
case 3:
g.setColor(Color.green);
g.fillOval(120, yVerde, 20, 20);
g.setColor(Color.black);
g.fillOval(120, yRosso, 20, 20);
g.fillOval(120, yGiallo, 20, 20);
break;
case 0:
g.setColor(Color.black);
g.fillOval(120, yRosso, 20, 20);
g.fillOval(120, yGiallo, 20, 20);
g.fillOval(120, yVerde, 20, 20);
}
}
}
<HTML>
<HEAD>
<TITLE>Applet HTML Page</TITLE>
</HEAD>
<BODY>
<H3><HR WIDTH="100%">Applet HTML Page<HR WIDTH="100%"></H3>
<P>
<APPLET codebase="classes" code="lab3.class" width=350 height=200></APPLET>
</P>
<HR WIDTH="100%"><FONT SIZE=-1><I>Generated by NetBeans IDE</I></FONT>
</BODY>
</HTML>
Pagina 50 di 59
a cura di Claudio Beghetto
Applet Colors
package Colori;
import
import
import
import
import
import
java.applet.Applet;
java.awt.Color;
java.awt.Graphics;
java.awt.Graphics2D;
java.awt.Rectangle;
javax.swing.JOptionPane;
/**
*
* @author */
public class Colors extends Applet
{
public void init()
{
String input;
// chiedi all'utente i valori per il rosso, il verde e il blu
// il valore deve essere compreso tra 0.0 e 1.0
input = JOptionPane.showInputDialog("rosso:");
red = Float.parseFloat(input);
input = JOptionPane.showInputDialog("verde:");
green = Float.parseFloat(input);
input = JOptionPane.showInputDialog("blu:");
blue = Float.parseFloat(input);
}
Pagina 51 di 59
a cura di Claudio Beghetto
public void paint(Graphics g)
{
final int SQUARE_LENGTH = 100;
Graphics2D g2 = (Graphics2D)g;
// seleziona il colore nel contesto grafico
Color fillColor = new Color(red, green, blue);
g2.setColor(fillColor);
// costruisci e colora un quadrato, il cui centro corrisponda
// al centro della finestra
Rectangle square = new Rectangle(
(getWidth() - SQUARE_LENGTH) / 2,
(getHeight() - SQUARE_LENGTH) / 2,
SQUARE_LENGTH,
SQUARE_LENGTH);
g2.fill(square);
}
private float red;
private float green;
private float blue;
}
Pagina 52 di 59
a cura di Claudio Beghetto
Applet Temperature
import
import
import
import
java.applet.Applet;
java.awt.Graphics;
java.awt.Graphics2D;
java.awt.Rectangle;
public class Temperature extends Applet
{
public void paint(Graphics g)
{
Graphics2D g2 = (Graphics2D)g;
month = 0;
units = new UnitConverter(0, 12, 0, 40,
getWidth(), getHeight());
final int
final int
final int
final int
final int
final int
final int
final int
final int
final int
final int
final int
JAN_TEMP = 11;
FEB_TEMP = 13;
MAR_TEMP = 16;
APR_TEMP = 20;
MAY_TEMP = 25;
JUN_TEMP = 31;
JUL_TEMP = 33;
AUG_TEMP = 32;
SEP_TEMP = 29;
OCT_TEMP = 23;
NOV_TEMP = 16;
DEC_TEMP = 12;
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
drawBar(g2,
JAN_TEMP);
FEB_TEMP);
MAR_TEMP);
APR_TEMP);
MAY_TEMP);
JUN_TEMP);
JUL_TEMP);
AUG_TEMP);
SEP_TEMP);
OCT_TEMP);
NOV_TEMP);
DEC_TEMP);
}
public void drawBar(Graphics2D g2, int temperature)
{ // costruisci un rettangolo per questo mese e per la sua temperatura
Rectangle rect
= new Rectangle(month, 0, 1, temperature);
// converti le coordinate in pixel e disegna
units.convert(rect);
g2.draw(rect);
Pagina 53 di 59
a cura di Claudio Beghetto
month++;
}
private int month;
private UnitConverter units;
}
Pagina 54 di 59
a cura di Claudio Beghetto
Applet Orologio
/*
*<html>
<head>
</head>
<body>
<applet code = "orol.class">
</applet>
</body>
</html>
*/
/*
viene creata una classe che eredita Applet. Vengono implementati i metodi Start, stop, paint.
viene creato un thread per gestire lo scorrere del tempo che viene implementato dal metodo run.
infine ad ogni secondo trascorso viene ridisegnata la stringa con l'ora.
*/
import
import
import
import
import
java.lang.*;
java.applet.*;
java.awt.*;
java.util.*;
java.text.*;
public class orol extends Applet implements Runnable{
private Thread clockThread = null;
private Calendar oldTime = null;
public void start(){
if (clockThread == null){
clockThread = new Thread(this, "orol");
clockThread.start();
}
}
public void run(){
while(clockThread != null){
while(Calendar.getInstance() == oldTime && oldTime != null);
repaint();
}
}
public void stop() {
clockThread = null;
}
public void paint(Graphics g){
oldTime = Calendar.getInstance();
DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
Pagina 55 di 59
a cura di Claudio Beghetto
g.setColor(Color.LIGHT_GRAY);
g.fillRect(20,30,80,30);
g.setColor(Color.blue);
g.drawRect(22, 32, 80, 30);
g.drawRect(20, 30, 80, 30);
g.drawString(formatter.format(oldTime.getTime()), 40, 50);
try{
Thread.sleep(100);
}catch(Exception e){}
}
}
Pagina 56 di 59
a cura di Claudio Beghetto
Creare un Eseguibile con Launch4j
Primo:
Con Clean & Build si crea un file .jar (Apertura.jar) nella directory interna (dist) al Package
Launch4j non converte l'applicazione in un eseguibile, perchè questo provoca spesso molti problemi.
Semplicemente si pone come wrapper verso l'applicazione Java, ed è quindi comunque necessario che il sistema
abbia installata una qualche versione del Java Runtime Environment. Potete scaricare Launch4j dal sito ufficiale
del progetto.
Per Salvare un file di Configurazione (xml) e Creare
l’eseguibile (exe)
Pagina 57 di 59
a cura di Claudio Beghetto
Risultato dell’esercizio ese 9, qui diventato : ApriDispense2.exe
Pagina 58 di 59
<launch4jConfig>
<dontWrapJar>false</dontWrapJ
ar>
<headerType>gui</headerType>
<jar>C:\Documents and
Settings\...\Documenti\Net
BeansProjects\APertura\d
ist\APertura.jar</jar>
<outfile>C:\Documents and
Settings\..\Desktop\ApriDi
spense2.exe</outfile>
<errTitle />
<cmdLine />
<chdir />
<priority>normal</priority>
<downloadUrl>http://java.com/d
ownload</downloadUrl>
<supportUrl />
<customProcName>false</custo
mProcName>
<stayAlive>false</stayAlive>
<manifest />
<icon />
- <classPath>
<mainClass>Apri</mainClass>
<cp>Apri</cp>
</classPath>
- <jre>
<path />
<minVersion>1.6.0_11</minVersi
on>
<maxVersion />
<jdkPreference>preferJre</jdkPr
eference>
</jre>
</launch4jConfig>
a cura di Claudio Beghetto
LIBRERIE
java.applet , serve per creare dei programmi che girano sui web browsers, chiamati
applet.
java.awt, questo package e i suoi sottopackages implementano le classi per
implementare i controlli GUI, per implementare interfacce grafiche, oltre agli strumenti
per il disegno, manipolazione di immagini, stampa e altre funzionalità
java.beans, package che permette di definire componenti Java e di utilizzarli in altri
programmi.
java.rmi, package per l'invocazione di metodi remoti, ovvero di metodi di oggetti che si
trovano ovunque sulla rete, per costruire delle applicazioni distribuite.
java.security, ci sono classi che implementano le funzioni di sicurezza, come ad
esempio classi utilizzate per crttografare documenti prima di mandarli in rete.
java.sql, interfaccia tra il linguaggio Java e il linguaggio per basi di dati SQL.
java.text, classi molto utili per l'interazionalizzazione.
javax.accessibility, classi che supportano tecnologie a sostegno degli utenti disabili.
javax.swing, è un estensione di java.awt, per costruire applets e applicazioni grafiche è
un portento.
org.omg.CORBA, permette di interfacciare il linguaggio Java con il linguaggio CORBA.
Pagina 59 di 59
a cura di Claudio Beghetto