Au programme cette semaine, un peu de synchronisation...

Imaginez que dans une classe, vous avez besoin de faire des initialisations, mais que vous ne voulez faire ces initialisations qu'au premier appel.

Vous écrivez alors ceci :

private static Boolean inited = Boolean.FALSE;
...
public void doJob() {
  // On commence par initialiser ce qui doit l'être
  synchronized (inited) { 
    if (!inited) {
      init();
      inited = Boolean.TRUE;
    }
  }
 
  // On fait le boulot
  ...  
}
...

Or ce code peut poser problème. Pourquoi ?

Est-il possible que le programme suivant provoque l'affichage ci-dessous ?

public class TestEq {  
    public static void main(String... args) {
        // Déclaration de i1, i2 et i3
 
        i1 = 127; i2 = 127; i3 = 127;
        System.out.println(i1 == i2);
        System.out.println(i2 == i3);
 
        i1 = 128; i2 = 128; i3 = 128;
        System.out.println(i1 == i2);
        System.out.println(i2 == i3);
    }
}

true
true
true
false

Si oui, quelles sont les déclarations possibles de i1, i2 et i3 pour cela ?

A votre avis, le code suivant : null ou pas null ?

public class NullOuPasNull {
    static String message = "Pas null";
 
    public NullOuPasNull getNull() {
        return null;    
    }
 
    public static void main(String[] args) throws Exception {
        NullOuPasNull o = new NullOuPasNull();
 
        System.out.println(o.getNull().message);
    }
}

Que diriez-vous du code suivant ?

public class TiensUneURL {
    public static void main(String... args) {
        System.out.println("Une petite curiosité...");
        http://olivier.croisier.free.fr/blog/index.php?2008/10/19/93-java-quiz-19   // L'URL de ce billet
        System.out.println("Qu'en dit le compilateur ?");
    }
}

(essayez de trouver la réponse sans coller le code dans un IDE...)

Que fait ce code ? (et pourquoi ?)

class Koassah{public static void main(String[] args){\u0066or(int
\u0020$:"m¾\"®Æ¤¾\u01b0¤´È:\"À¾\"ª´Ê\"\u0138iÀ¼¼¬¾Ê\"`\u0158".to\u0043h\u0061rArray()
)System./*goto/*$/%\u0126//^\u002A\u002Fout.print((char)(($>>+
(~'"'&'#'))+('<'>>('\\'/'.')/\u002Array.const(~1)\*\u002F)));}}
 

Voilà un quiz où il ne suffira pas de copier/coller le code dans Eclipse pour donner la réponse... ;-)

Comment écrire un programme Java sans méthode main, qui affiche (sans aucune erreur) «Hello world!» lorsqu'on l'exécute ?

Qu'affiche ce code ?

class Super {
    static { System.out.print("**Super** "); }
}
 
class Un {
    static { System.out.print("**Un** "); }
}
 
class Deux extends Super {
    static { System.out.print("**Deux** "); }
 
    static final String DEUX = "dEuX";
}
 
class TestClasse {
    public static void main(String[] args) throws Exception {
        Un          o = null;
        Class<Deux> c = Deux.class;
 
        System.out.println(Deux.DEUX);
        System.out.println(((Object) o == (Object) c));
        System.out.println(c.equals(o));
        System.out.println(c);     // Appelle toString() sur c.
        System.out.println(c.newInstance());
    }
}

Que fait ce code ?

Edit : Le code a été modifié pour corriger certaines typos qui empêchaient de démontrer le point technique mis en avant dans ce quiz.

public final class AddUtils {
 
	public static Number add(Collection<Integer> ints) {
		int sum = 0;
		for (int i : ints) {
			sum += i;
		}
		return sum;
	}
 
	public static Number add(Collection<Long> longs) {
		long sum = 0;
		for (long l : longs) {
			sum += l;
		}
		return sum;
	}
 
	public static void main(String... args) {
		List<Integer> ints = Arrays.asList(1, 2, 3, 4);
		Number intSum = AddUtils.add(ints);
 
		List<Long> longs = Arrays.asList(1L, 2L, 3L, 4L);
		Number longSum = AddUtils.add(longs);
 
		System.out.println(intSum.equals(longSum));
	}
}

(Presque) tout le monde connait le pattern suivant :

public class MaClasse implements java.io.Serializable {
    private static final MaClasse INSTANCE = new MaClasse();
 
    private MaClasse() {
        // ...
    }
 
    public static MaClasse getInstance() {
        return INSTANCE;
    }
 
    private Object readResolve() {
        return INSTANCE;
    }
 
    public void bosseUnPeu() {
        // ...
    }
}

Avec les dernières versions de Java, y a-t-il une autre manière, beaucoup plus simple et concise, d'implémenter ce pattern de conception ?

Une classe Java peut-elle être déchargée de la mémoire ?