Quando si ha che fare con gli oggetti, è buona norma riderifinire il metodo equals e anche il metodo hashcode().
In particolare, se abbiamo a che fare per esempio con mappe (hashset, set, etc), gli oggetti verranno inseriti in locazioni di
memoria identificati con un valore detto bucket. All’interno dello bucket ci possono essere più oggetti.
Questo bucket è dato appunto dal metodo hashCode.
Il metodo hashcode deve essere ridefinito in base alle seguenti regole:
– se due oggetti risultano uguali in base a equals() allora anche i loro hash code devono essere uguali.
– se due oggetti hanno hash code differenti, allora equals() deve indicare che sono diversi.
Esistono anche gli altri 2 casi:
– se due oggetti sono diversi, secondo equals, possono avere hash code uguali o differenti.
– se due oggetti hanno hash code uguali, possono essere uguali o no.
Quando si fa una ricerca di un oggetto nella mappa, prima si controlla se si ha il suo hashcode(bucket),
se, e solo se, il bucket è presente si chiamare il metodo equals per fare l’ultima verifica. Questo
perche come abbiamo detto nello stesso bucket possono essere inseriti più bucket.
Swing – Introduzione
Per fare grafica in java esistono principalmente due framework:
AWT, un package pesante ormai obsoleto
Swing, un package che a riutilizzato molte componenti di AWT ma migliorate e allegerite. Si riconoscono le componenti che discendono da AWT perche hanno mantenuto lo stesso nome ma è stata aggiunta una J.
I listener-adapter sono degli elementi che, associati a qualche componente, rimangono in ascolto di qualche evento (qualche click, focus, etc) che coinvolge il component suddetto. La differenza tra listener e adapter è, fondamentalmente, che usando i listener, essendo interfaccie, si deve implementare tutti i metodi, mentre con gli adapter, che a loro volta estendono i listener, si deve implementare solo alcuni metodi.
Un Component è un oggetto che può essere visualizzato a schermo e interagisce con l’utente tramite eventi, ad esempio con un click del mouse su tale oggetto. Esempi di Component sono i pulsanti, le checkbox, etc.
Un Container è un component che può contenere altri component, tramite i metodi add(Component c) e remove(Component c).
Un container che non è contenuto in nessun altro oggetto viene detto Window.
Una Window non ha bordi, barre o controlli’ e ha la possibilità di contenere diversi Component sulla sua superficie.
Un Frame, invece, è una window provvista di bordi che può essere ridimensionata o ridotto a icona tramite mouse. I JFrame sono i frame di JSwing, che sono uguali ai frame di AWT ma ne risolvono alcune problematiche.
Un JFrame può essere considerato come un contenitore di “alto livello”.Al suo interno contiene una successione di sotto-contenitori, detti Pannelli, ognuno con le sue particolarità:
- Root Pane, poggiato direttamente sulla superficie del JFrame, che contiene il glass pane;
- Glass Pane, un pannello che cattura le azioni effettuate tramite il puntatore del mouse sulla finestra;
- Layered Pane, serve a contenere un eventuale menù e il content pane;
- Content Pane, che serve a contenere tutti gli elementi della GUI (componenti, contenitori, elementi di alto e basso livello) da aggiungere al JFrame.
Si puo usare direttamente il Content Pane per aggiungere gli oggetti della GUI, ma per avere un maggior controllo, si preferisce usare ulteriori pannelli generici (JPanel).
Un Toolkit è un oggetto AWT che da informazioni sulle caratteristiche dell’oggetto sul quale viene chiamato.
Codice Di Esempio
package allin.frontend.gui;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
public class GUIMain extends JFrame {
private JMenuBar barraDeiMenu;
private JMenu menu1, menu2, menu3;
private JMenuItem menuItem1, menuItem2, menuItem3, menuItem4;
public GUIMain() throws IOException {
this.setTitle(“Esempio di JFrame con menù”);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Toolkit mioToolkit = Toolkit.getDefaultToolkit();
Dimension dimensioniSchermo = mioToolkit.getScreenSize();
this.setSize((int) dimensioniSchermo.getWidth()-200,
(int) dimensioniSchermo.getHeight()-100);
// NOTA IMPORTANTE: l’origine del sistema di riferimento dello schermo
// (punto (0,0)) è situata IN ALTO A SINISTRA; (x,y)valori y positivi
// ‘scendendo’, x positivi proseguendo ‘verso destra’.
// con questo metodo si dice dove deve essere messo l angolo a sinistra
// del frame
this.setLocation(0, 0);
// Credo ed aggiungo la barra del menù, alcuni menù e voci del menù di
// esempio
barraDeiMenu = new JMenuBar();
menu1 = new JMenu(“File”);
menu2 = new JMenu(“Finestra”);
menu3 = new JMenu(“Aiuto”);
menu1.setMnemonic(‘f’);
menuItem1 = new JMenuItem(“Apri”);
menuItem2 = new JMenuItem(“Esci”);
menuItem3 = new JMenuItem(“Schermo intero”);
menuItem4 = new JMenuItem(“?”);
menuItem1.setMnemonic(‘a’);
menu1.add(menuItem1);
menu1.add(menuItem2);
menu2.add(menuItem3);
menu3.add(menuItem4);
barraDeiMenu.add(menu1);
barraDeiMenu.add(menu2);
barraDeiMenu.add(menu3);
this.setJMenuBar(barraDeiMenu);
Container content = getContentPane();
JPanel provaPanel = new JPanel();
JButton button = new JButton(“Click”);
provaPanel.add(button);
content.add(provaPanel,BorderLayout.EAST);
JPanel provaPanel1 = new JPanel();
JButton button1 = new JButton(“Clack”);
provaPanel1.add(button1);
content.add(provaPanel1,BorderLayout.WEST);
}
public static void main(String[] args) {
GUIMain pm;
try {
pm = new GUIMain();
pm.setVisible(true);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Raspberry
Il raspberry è un piccolo computer sviluppato nel Regno Unito della grandezza di circa una carta di credito venduto a basso costo.
Ha una CPU da 700MHz e una RAM 256/512 Mbyte. Non ha harddisk ma per il boot e per la memorizzazione dei dati si affida ad una scheda SD. Si basa su un sistema operativo con kernel Linux. E’ dotato di un connettore GPIO che permette di interfacciarsi con dispositivi esterni, quali ad esempio LED, rele, etc. La connessione ad internet è garantita dalla porta lan mentre mouse e tastiera vengono collegati attraverso le due porte USB. E’ presente una uscita audio con jack da 3,5mm mentre il collegamento al monitor avviene tramite cavetto hdmi o RCA. La potenza assorbita è di appena 700 mhA e 3,5 volt
Installare il sistema operativo su scheda SD
-Scaricare l’immagine del sistema operativo da qui . Ci sono più versioni, io personalmente ho scelto “Soft-float Debian” essendo l’unico, per ora, su cui può girare java.
– Scaricare il file win32diskimager e installarlo.
– Lanciare win32diskimager, selezionare l’immagine del sistema operativo e la scheda SD.
– Cliccare su write e abbiamo la scheda SD pronta per l’uso
Se si ha un sistema operativo diverso da windows seguire queste istruzioni
Arduino: Controllare temperatura e umidità
DESCRIZIONE
Misurare temperatura e umidità tramite il sensore DHT11 e arduino.
Osservando il datasheet del DHT11 si nota che va collegata anche una resistenza (detta di pull-up) sul pin 2, e anche che vengono usati solo 3 piedini su 4 disponibili.
qui troverete la libreria che permette di usarlo
MATERIALE USATO
Sensore umidità e temperatura DHT11
Resistenza da 5k
Arduino
SCHEMA
SKETCH
#include
dht11 DHT11;
#define DHT11PIN 2
void setup()
{
Serial.begin(9600);
}
void loop()
{
int chk = DHT11.read(DHT11PIN);
Serial.print("stato sensore: ");
switch (chk)
{
case 0: Serial.println("OK"); break;
case -1: Serial.println("Checksum error"); break;
case -2: Serial.println("Time out error"); break;
default: Serial.println("Unknown error"); break;
}
Serial.print("Umidita (%): ");
Serial.println((float)DHT11.humidity, 2);
Serial.print("Temperatura (Celsius): ");
Serial.println((float)DHT11.temperature, 2);
delay(5000);
}
Arduino: controllare una lampada da 220V
Lo scopo è interrompere la fase di una 220v, che alimenta una lampadina, per 5 secondi e poi mantenerla per altri 5 e cosi via.
Materiale occorrente:
1 resistenza da 330 ohm
1 rele con input 28VDC10A – ouput 220/250VAC10A
1 transistor BC547
1 diodo 1N4001
Il rele è un interruttore controllato da una bobina. In base a quanta corrente entra nella bobina l’interruttore 1 sarà chiuso su 3 o su 2. Da notare che si controlla un circuito con la corrente di un’altro circuito, nel nostro caso si controlla la 220V con un circuito di 6V.
Lo schema seguito è quello sotto
Lo sketch caricato su arduino:
int tempPinBase = 13;
void setup()
{
Serial.begin(9600); //apertura porta seriale, set della velocità a 9600 bps
}
void loop()
{
digitalWrite(tempPinBase, HIGH);
delay(5000);
digitalWrite(tempPinBase, LOW);
delay(5000);
//aspetta 5 secondo prima di ripetere
}
come si vede è abbastanza semplice. Manda tensione alta, conta fino a 5, spegne, conta fino a 5.
Prima di provarlo direttamente con la 220V (con la 220V SI MUORE) ho messo al posto della lampada e del generatore, una resistenza e un LED alimentati da 5V.
Transistor BJT
Un transistor è un dispositivo elettronico a tre terminali: base, collettore e emettitore,
a volte anche chiamato BJT.
E’ formato unendo 3 strati NPN o PNP. La versione NPN è quella più usata.
Ponendo l’emettitore a massa si dice che la il transistor è viene usato con la configurazione “emettitore comune”.
La sua caratteristica principale è quella di essere pilotato in corrente, a differenza del JFET che è, invece, pilotato dalla tensione.
Il transistor ha due possibili utilizzi: interruttore controllato o amplificatore lineare .
Interruttore controllato
Se la corrente nella base è nulla allora anche le correnti nel collettore e nell’emettitore
sono nulle. Lo si può vedere come un interruttore aperto tra collettore ed emettitore. In questo caso si dice che il transistor è in “interdizione“.
Se la corrente nella base è sufficiente, si ha una corrente che entra nel collettore ed esce dall’emettitore, quindi è come se si avesse un interruttore chiuso tra collettore ed emettitore.
A differenza di un normale interruttore, la corrente può scorrere tra Collettore ed Emettitore ma non viceversa (si noti il verso della freccia sull’emettitore). La corrente di base può essere solo entrante. Si ha che la corrente del collettore è uguale alla corrente della base sommata alla corrente dell’emettitore.
In questo caso si dice che il transistor è in “saturazione“.
Amplificatore lineare
Il seguente grafico mostra la corrente di collettore Ic in funzione della tensione Vce, mantenendo costante la Ib
All’aumentare della Vce, inizialmente la Ic è zero; poi aumenta linearmente e rapidamente fino al ginocchio; superato il ginocchio, la Ic resta praticamente costante, anche se aumenta la Vce,come se fosse un interruttore chiuso.
Si nota che, in base alla corrente di base, mantenendo costante la Vce, possiamo controllare la Ic, e variarla in modo lineare.
Quindi alimentando il collettore con una certa tensione e la base con un altra, possiamo con una piccola Ib controllare, e quindi anche aumentarla (amplificarla), una grande Ic.
Per una spiegazione più approfondita, qua troverete un ottimo tutorial.
Elettronica di Base: Generatori Continua
Esistono due tipi di generatori in continua: di tensione e di corrente.
Generatore di tensione
Lo scopo principale di questo generatore è fornire una tensione costante, detta di targa, a prescindere da quale sia il carico collegato. Per poter fare questo, essendo V=R*I, variare la corrente in base al carico.
Nel caso in cui si abbia un R piccolissima, o un corto circuito, il generatore dovrà erogare una corrente altissima, nel far questo o si romperà o salterà qualche fusibile di protezione.
Quindi riassumendo avremo:
- la tensione in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
- la corrente in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.
Nel 99% dei casi si ha a che fare con generatori di tensione.
Generatore di corrente
In questo caso è la corrente che deve rimanere sempre costante. Per fare ciò, il generatore varierà la tensione. Quindi nel caso di un circuito aperto la tensione salirà fino a quando o si rompe o scattano dei circuiti di sicurezza che fanno scaricare la tensione accumulata.
Riassumendo, nel caso di un generatore di corrente si ha:
- la corrente in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
- la tensione in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.
Android: Grafica 2D, le basi
I compontenti di base per poter fare grafica 2D con android sono:
la View, che tramite le chiamate al suo metodo onDraw ci permette di ridisegnare lo schermo.
il Canvas, la classe che contiene le api fondamentali per disegnare (es. drawLine(), drawCircle(), etc.) su una immagine(bitmap) .
la Bitmap, che contiene i pixel, ossia l’immagine vera e propria.
un Paint, che descrive i colori e gli stili per disegnare.
con l’esempio sotto disegniamo un rettangolo rosso
Bitmap bitMapEsempio = BitmapFactory.decodeResource(res, R.drawable.qualche img);
Canvas canvasMaschera = new Canvas(bitMapEsempio);
Paint paint = new Paint();
paint.setColor(Color.RED);
canvasMaschera.drawRect(left, top, right, bottom, paint);// se paint è null si hanno immagini opache
non alllocare troppi oggetti nel metodo View.onDraw, questo metodo viene richiamato tante volte, e quindi potrebbe rallentare di molto l’app.
Hibernate: Strategie di Fetch
Quando si a che fare con delle entity (padre) che hanno delle collection di altre entity (figli), Hibernate offre la possibilità di “tirare su” dal db la collection dei figli subito, nel momento in cui si accede al padre, o in un secondo momento, quando si cerca di accedere direttamente ai figli.
L’attributo che indica QUANDO prendere la collection dal db è lazy=”true|false”. Con true,detto anche comportamento lazy, l’oggetto figlio sarà preso dal db solo nel momento in cui viene invocato. Questo fa si che le query siano molto veloci, si prendono dal db solo i padri, però, se la lettura dei figli avviene fuori dal contesto di hibernate (come ad esempio un EJB), potremmo avere che la sessione è chiusa e quindi verrà sollevata una exception.
Con lazy = “false”, detto anche comportamento eager, non avremo problemi di sessione chiusa ma le prestazioni potrebbero decadere in quanto con una singola query si potrebbe tirare su tutto il DB.
Per indicare COME i figli devono essere letti dal db si l’attributo fetch = “select|subselect|join|batch”.
select: una seconda select è usata per leggere la collection, quindi Hibernate eseguirà una select per il padre e una select per i figli.
Se, per esempio, abbiamo 10 entity padre (A) e ciascuna padre ha al suo interno una collection di figli (B) di grandezza qualsiasi, verranno eseguite le seguenti select:
select A –> eseguita 1 volta, ci darà tutti i padri che ci interessano
select B where A.Id = ? —-> eseguita altre 10 volte
avremo quindi in totale 11 select eseguite. Questa opzione è quella di default.
join: verrà eseguita un’unica select, mettendo in JOIN il padre con tutti i suoi figli.
batch-size=N: questo è un po contorto, esso indica non quanti elementi della collection devono essere letti ma indica quante collection devono essere lette. Riconsiderando l’esempio precendente, se batch-size = 5 leggeremo al massimo 5 collection di figli per volta
select A —> 1 volta
select B where A.id in ( ?, ?, ?, ?, ? ) –> eseguito 10/5= 2 volte
le select totali questa volta sono 3, al posto delle 11 select richieste normalmente, un bel risparmio di tempo.
subselect: hibernate utilizzerà le subquery. In questo caso le select generate sono
select A—> 1 volta
select B where A.id in ( select A ) –> 1 volta
quindi in questo caso avremo 2 select in tutto.
Ogni opzione ha i suoi pro e i suoi contro, molto dipende dal tipo di DB usato e dalla complessità dello schema.
Android: Toast con Immagine e vibrazione
Codice per visualizzare un Toast di Android con una immagine e vibrazione:
package com.AndroidImageToast;
import android.app.Activity;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
public class ImageToastExample extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Toast toast1 = new Toast(getBaseContext());
LinearLayout toastLayout = new LinearLayout(getBaseContext());
toastLayout.setOrientation(LinearLayout.HORIZONTAL);
ImageView image = new ImageView(getBaseContext());
TextView text = new TextView(getBaseContext());
image.setImageResource(R.drawable.radiazioni);
toastLayout.addView(image);
toastLayout.addView(text);
toast1.setView(toastLayout);
toast1.setGravity(Gravity.CENTER | Gravity.CENTER, 0, 0);
Vibrator v = (Vibrator) getApplicationContext()
.getSystemService(Context.VIBRATOR_SERVICE);
v.vibrate(300);