FAQ Langage JavaConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public final class TemperatureEvent extends EventObject {      
     private final double oldTemperature; 
     private final double newTemperature; 
  
    /** 
     * Cr�e une nouvelle instance. 
     * @param source La source de l��v�nement. 
     * @param oldTemperature L'ancienne temp�rature. 
     * @param newTemperature La nouvelle temp�rature. 
     */ 
    public void TemperatureEvent(Object source, double oldTemperature, double newTemperature) { 
        super(source); 
        this.oldTemperature = oldTemperature; 
        this.newTemperature = newTemperature; 
    } 
  
    /** 
     * Retourne la temp�rature avant modification. 
     * @return Une temp�rature en degr�s Kelvin. 
     */ 
    public double getOldTemperature() { 
        return oldTemperature; 
    } 
  
    /** 
     * Retourne la temp�rature apr�s modification. 
     * @return Une temp�rature en degr�s Kelvin. 
     */ 
    public double getNewTemperature() { 
        return newTemperature; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface TemperatureListener extends EventListener { 
    /** 
     * Invoqu�e quand la temp�rature monte. 
     * @param event Les d�tails de l��v�nement. 
     */ 
    public void temperatureRaised(TemperatureEvent event); 
  
    /** 
     * Invoqu�e quand la temp�rature baisse. 
     * @param event Les d�tails de l��v�nement. 
     */ 
    public void temperatureDropped(TemperatureEvent event); 
}

1
2
3
4
5
6
7
8
9
public class TemperatureAdapter implements TemperatureListener { 
    @Override 
    public void temperatureRaised(TemperatureEvent event) { 
    } 
  
    @Override 
    public void temperatureDropped(TemperatureEvent event) { 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class TemperatureSensor { 
    // Conteneur pour tous les observateurs sur cet objet. 
    private final List listenerList = new LinkedList(); 
  
    /** 
     * Enregistre un �couteur de temp�rature. 
     * @param listener L��couteur. 
     */ 
    public void addTemperatureListener(TemperatureListener listener) { 
        if (listener == null) { 
            return; 
        } 
        // On ajoute le listener et son type. 
        // Cela permet de stocker plusieurs types de listeners dans le m�me conteneur. 
        listenerList.add(TemperatureListener.class); 
        listenerList.add(listener); 
    } 
  
    /** 
     * D�senregistre un �couteur de temp�rature. 
     * @param listener L��couteur. 
     */ 
    public void removeTemperatureListener(TemperatureListener listener) { 
        if (listener == null) { 
            return; 
        } 
        removeListener(TemperatureListener.class, listener); 
    } 
  
    /** 
     * M�thode g�n�rique pour d�senregistrer un �couteur. 
     * @param listenerClass Le type de l��couteur. 
     * @param listener L��couteur. 
     */ 
    private void removeListener(Class listenerClass, Object listener) { 
        int listSize = listenerList.size();         
        for (index = 0�; index < listSize�; index += 2) { 
            // Comme un listener peut impl�menter plusieurs interfaces et s'enregistrer plusieurs fois, 
            // on v�rifie qu'on enl�ve le premier rencontr� qui porte le bon type. 
            if (listenerList,get(index) == listenerClass && listenerList.get(index + 1) == listener) { 
                listenerList.remove(index + 1); 
                listenerList.remove(index); 
                break; 
            } 
        } 
    } 
}

1
2
3
4
5
6
7
TemperatureSensor senseur = [...] 
senseur.addTemperatureListener(new TemperatureAdapter() { 
    @Override 
    public void temperatureRaised(TemperatureEvent event) { 
        System.out.printf("La temp�rature est mont�e de %.2fK � %.2fK.%n", event.getOldTemperature(), event.getNewTemperature()); 
    } 
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
protected void fireTemperatureRaised(double oldTemperature, double newTemperature) { 
    TemperatureEvent event = null; 
    int listSize = listenerList.size(); 
    // On parcourt la liste � rebours. 
    for (int index = listSize - 2�; index >= 0�; index -= 2) { 
        // Seules les instances de TemperatureListener nous int�ressent. 
        if (listenerList.get(index) == TemperatureListener.class) { 
            // On cr�e l'objet event de mani�re "lazy" (paresseuse), uniquement quand on en a vraiment besoin. 
            if (event == null) { 
                event = new TemperatureEvent(this, oldTemperature, newTemperature); 
            } 
            TemperatureListener  listener = (TemperatureListener)listenerList.get(index + 1); 
            // On invoque la notification appropri�e sur le listener. 
            listener.temperatureRaised(event); 
        } 
    } 
}

1
2
3
4
5
6
7
8
// Sauvegarde de l'ancienne temp�rature. 
double oldTemperature = temperature; 
// Relever la temp�rature sur le capteur physique. 
temperature = [...] 
// Lancer une notification d��l�vation de temp�rature si besoin. 
if (temperature > oldTemperature) { 
    fireTemperatureRaised(oldTemperature, temperature); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public final class TotoEvent extends EventObject { 
  
    [...] 
  
    private boolean consumed = false; 
  
    /** 
     * Consomme l��v�nement. 
     */ 
    public void consume() { 
        consumed = true; 
    } 
  
    /** 
     * Indique si l��v�nement a �t� consomm�. 
     * @return {@code True} si le test est v�rifi�, {@code false} sinon. 
     */ 
    public boolean isConsumed() { 
        return consumed; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
public class AnObserver implements TotoListener { 
  
    [...] 
  
    @Override 
    public void totoEventReceived(TotoEvent event) { 
        // G�rer l��v�nement. 
        [...] 
        // Consommer l��v�nement pour emp�cher la propagation. 
        event.consume(); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void fireTotoEvent() {  
    TotoEvent event = null;  
    int listSize = listenerList.size();  
    // On parcourt la liste � rebours.  
    for (int index = listSize - 2�; index >= 0�; index -= 2) {  
        // Seules les instances de TotoListener nous int�ressent.  
        if (listenerList.get(index) == TotoListener.class) {  
            // On cr�e l'objet event de mani�re "lazy" (paresseuse), uniquement quand on en a vraiment besoin.  
            if (event == null) {  
                event = new TotoEvent(this);  
            }  
            TotoListener listener = (TotoListener)listenerList.get(index + 1);  
            // On invoque la notification appropri�e sur le listener.  
            listener.totoEventReceived(event);  
            // si l'event a �t� consomm�, on arr�te la propagation. 
            if (event.isConsumed()) { 
                break;  
            } 
        }  
    }  
}