Oggi vi presento una bella (a mio vedere) novità introdotta da Java7, si tratta del “try with resources”, ovvero come dimenticarsi di rilasciare le risorse come ad esempio la connessione al db 
Vediamo in dettaglio di cosa parlo..
Come avreste scritto un programmino per fare una query a db con java6??
Pressocchè in questo modo credo:
public void queryJavaSei() {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
conn = DriverManager.getConnection(blablabla);
stmt = conn.createStatement();
rs = stmt.executeQuery(blablabla);
while (rs.next()) {
rs.getblablabla;
}
} catch (SQLException e) {
log.blablabla;
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
log.blablabla;
}
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
log.blablabla;
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
log.blablabla;
}
}
}
}Bello lungo e complicato rispetto alla versione java7 qui di seguito:
public void queryJavaSette() {
try(Connection conn = DriverManager.getConnection(blablabla);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(blablabla)) {
while (rs.next()) {
rs.getblablabla;
}
} catch (SQLException e) {
log.blablabla;
}
}Così facendo si pone fine ad un’errore umano che crea molti grattacapi in produzione/esercizio dove le connessioni non chiuse possono portare al collasso del server.
Al lavoro mi è capitato di dover prendere il padre di un oggetto selezionato nel tree view, operazione semplicissima ma che se non si conosce il trucchetto potrebbe richiedere un pò di tempo prima di implementarla, il problema sta nel fatto che la libreria su citata non mette a disposizione un metodo tipo “getParent()” per la classe TreeViewer ma bisogna passare per il relativo ContentProvider.
Vediamo un’esempio esplicativo della soluzione:
// Prendo l'elemento selezionato nel treeView
Object oggettoSelezionato = ((IStructuredSelection)classeTreeView.getSelection()).getFirstElement();
// Prendo il contentProvider del treeView
ITreeContentProvider provider =(ITreeContentProvider) classeTreeView.getContentProvider();
// Mi faccio restituire dal contentProvider il padre dell'oggetto selezionato
Object parent = provider.getParent(oggettoSelezionato);
Come si può facilmente vedere l’operazione richiede un passaggio in più per arrivare al padre ma non è per nulla complicata
Spero che possa servire a qualcuno, a me sicuramente ritornerà utile.
Se nella nostra applicazione Java dobbiamo fare calcoli in cui abbiamo numeri con la virgola, tipo calcoli scientifici e calcoli finanziari non dobbiamo utilizzare mai i tipi di dato a virgola mobile come float e double in quanto la loro rappresentazione in binario non riesce ad essere precisa e quindi presenta piccoli problemi di arrotondamento. Ad esempio, non esiste una rappresentazione precisa nel sistema decimale di 1/3 come non esiste una rappresentazione precisa di 1/10 in binario..
Vediamo un esempio:
/**
* @author Alessandro Musacchio
*
*/
public class Numeri {
public static void main(String[] args) {
double a = 2.0000001d;
double b = 1.0000001d;
System.out.print("Calcolo con i double: ");
System.out.println(a - b);
float af = 2.0000001f;
float bf = 1.0000001f;
System.out.print("Calcolo con i float: ");
System.out.println(af - bf);
}
}Il risultato che danno entrambi i calcoli se eseguiti su un PC sono errati in quanto l’unico risultato ammisibile è: 1 senza alcun arrotondamento!
Vediamo ora come Java con gli ogetti BigDecimal ci permette di fare calcoli con la “massima” precisione:
import java.math.BigDecimal;
/**
* @author Alessandro Musacchio
*
*/
public class Numeri {
public static void main(String[] args) {
BigDecimal aBD = new BigDecimal("2.0000001");
BigDecimal bBD = new BigDecimal("1.0000001");
System.out.print("Calcolo con i BigDecimal: ");
System.out.println(aBD.subtract(bBD));
}
}Eseguendo questo pezzo di codice invece vedremo il risultato esatto!
Un piccolo esempio di rappresentazione di un movimento su una matrice, l’esempio è puramente esemplificativo..
Per realizzare un’applicazione con un’interfaccia grafica utilizzeremo poi i KeyListener per catturare gli eventi dei tasti freccia ed il paintComponent per stampare a video il movimento, e rappresenteremo gli oggetti con una classe ad-hock tipo “Omino”
import java.util.Scanner;
/**
* Semplice classe che implementa una matrice con
* un solo omino presente su di essa che si muove
* nelle direzioni
* nord : tasto 2
* sud : tasto 3
* est : tasto 4
* ovest : tasto 1
* uscita : tasto 0
*/
/**
* @author Alessandro Musacchio
*
*/
public class Matrice {
private int[][] matrice;
private int posX;
private int posY;
private int dim;
public Matrice(int dim) {
this.matrice = new int[dim][dim];
this.dim = dim;
this.posX = 0;
this.posY = 0;
// Setto la posizione iniziale da cui parte l'omino
this.matrice[posY][posX] = 1;
}
public int[][] getMatrice() {
return matrice;
}
public boolean muoviDestra() {
// Controllo se sono al bordo
if (posX+1 == dim) return false;
// Mi muovo
this.matrice[posY][posX] = 0; // Lascio il posto attuale
this.posX++; // Modifico le coordinate
this.matrice[posY][posX] = 1; // Occupo il nuovo posto
return true;
}
public boolean muoviSinistra() {
// Controllo se sono al bordo
if (posX-1 == -1) return false;
// Mi muovo
this.matrice[posY][posX] = 0; // Lascio il posto attuale
this.posX--; // Modifico le coordinate
this.matrice[posY][posX] = 1; // Occupo il nuovo posto
return true;
}
public boolean muoviSu() {
// Controllo se sono al bordo
if (posY-1 == -1) return false;
// Mi muovo
this.matrice[posY][posX] = 0; // Lascio il posto attuale
this.posY--; // Modifico le coordinate
this.matrice[posY][posX] = 1; // Occupo il nuovo posto
return true;
}
public boolean muoviGiu() {
// Controllo se sono al bordo
if (posY+1 == dim) return false;
// Mi muovo
this.matrice[posY][posX] = 0; // Lascio il posto attuale
this.posY++; // Modifico le coordinate
this.matrice[posY][posX] = 1; // Occupo il nuovo posto
return true;
}
/**
* @param args
*/
public static void main(String[] args) {
Matrice mappa = new Matrice(10);
Scanner sc = new Scanner(System.in);
int val = 0;
do {
val = sc.nextInt();
if (val == 1) {
if (mappa.muoviSinistra()) {
System.out.println("Mosso Sinistra");
} else {
System.out.println("Sei al bordo");
}
}
if (val == 2) {
if (mappa.muoviSu()) {
System.out.println("Mosso Su");
} else {
System.out.println("Sei al bordo");
}
}
if (val == 3) {
if (mappa.muoviGiu()) {
System.out.println("Mosso Giù");
} else {
System.out.println("Sei al bordo");
}
}
if (val == 4) {
if (mappa.muoviDestra()) {
System.out.println("Mosso Destra");
} else {
System.out.println("Sei al bordo");
}
}
} while (val != 0);
}
}
A volte può capitare che dobbiamo uscire non da un solo ciclo ma da due o più contemporaneamente al verificarsi di una certa condizione..
Per fare questo, etichettiamo i cicli e con l’istruzione break <etichetta> usciamo dal ciclo ed andiamo all’ altro!
Qui sotto vediamo un piccolo esempio per capire meglio:
public class esempio {
public static void main (String args[]) {
boolean condizione = true;
System.out.println("Inizio");
punto_uscita:while (true) {
while (true) {
System.out.println("Dentro secondo while prima del break");
if (condizione) {
break punto_uscita;
}
System.out.println("Dentro secondo while dopo del break");
}
}
System.out.println("Fine");
}
}
In questo post vedremo come creare un processo batch in java che eseguirà una semplice query nel database Oracle 10g attraveso il driver JDBC:ODBC.
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author Alessandro Musacchio
*/
public class Main {
public static void main(String[] args) {
Connection con = null;
Statement st = null;
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
con = DriverManager.getConnection("jdbc:oracle:thin:user/password@localhost:1521:XE");
String query = "update UTILITA set AVVIOTRIGGER=1";
st = con.createStatement();
st.addBatch(query);
st.executeBatch();
} catch (ClassNotFoundException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} catch (SQLException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}finally {
if( st != null)
st.close();
if( con != null)
con.close();
}
}
}
Gioco di scacchi in java e opensource!
Poco fa ho ultimato il caricamento della prima release Beta della mia interfaccia grafica per GNUChess e altri motori compatibili con xBoard chiamata 3dMChess.
Con questa relaese il software prende vita e si può notare la sua vera costituzione e formazione, in un futuro ci saranno sostanziali miglioramenti alla usabilità e alla stabilità.
Per ora gli sviluppatori italiani sono invitati a contribuire.. Ci sarebbe molto lavoro da fare, anche perchè avrei intenzione di inserire un gestore dei temi, sia 2d che 3d, in modo tale da lasciare all’ utente la scelta della vista e del tema che più gli piace.. Io ho scelto un tema “moderno”, abbinando le carte da poker che ultimamente vanno tantissimo con gli scacchi, così da creare un contrasto da modernità e vecchiaia..
Il software per funzionare necessita che sulla macchina, Linux o Windows che sia ci sia installato JavaSE_1.6 e la libreria Java3D. Ripeto che il software è da intendersi a scopo dimostrativo e/o didattico e che quindi non è pienamente buono per giocare realmente (anche se non è vietato farlo ).
Un problema comune quando si lavora con le Swing e le API Java3D è quello di incorrere nel sovraposizionamento della parte 3D sulle swing.
A me è capitato che il componente JMenu delle Swing andasse a finire sotto la parte 3D, questo perchè i componenti Swing sono detti lightweight mentre i componenti Java3D sono detti heavyweight.
Per risolvere il problema del JMenu basta incollare questa riga:
JPopupMenu.setDefaultLightWeightPopupEnabled(false);
Cerca Alessandro Musacchio!