(FR)
La cellule d'expertise de votre entreprise a développé un Timer pour que vous puissiez mesurer les performances de votre application, mais... ils ont juste oublié de fournir une méthode pour récupérer la valeur du compteur ! Comment faire pour l'afficher une fois la mesure prise ?
Vous ne pouvez intervenir que sur la classe Quiz41, et il est interdit de modifier le code existant ou d'utiliser la Réflexion.
Bonne chance !

(EN)
The Architects Team developed a Timer class to help you measure the performance of your code, but... they forgot to provide a method to get the timer's value ! How can you get it back and print it in the console ?
You can only alter the Quiz41 class ; modifying the already existing code or using Reflection is forbidden.
Good luck !

public class Quiz41 {
 
	public static void main(String[] args) throws InterruptedException {
 
		Timer timer = new Timer();
		timer.start();
		Thread.sleep(new Random().nextInt(2000));
		timer.stop();
 
	}
}

public class Timer {
 
	private TimerThread thread = new TimerThread();
 
	public void start() {
		thread.start();
	}
 
	public void stop() {
		thread.stop();
	}
 
	public static class TimerThread extends Thread {
		private AtomicInteger counter = new AtomicInteger(0);
 
		@Override
		public void run() {
			try {
				while (!isInterrupted()) {
					counter.incrementAndGet();
					Thread.sleep(100);
				}
			} catch (InterruptedException e) {
				interrupt();
			}
		}
 
		public int getCounter() {
			return counter.get();
		}
	}
}

To please your Project Manager, a former developer (yeaaars ago), you sometimes let him help you develop some "very important" parts of your application.

Today, he's in charge of displaying "Hello World" by iterating on a list containing those words. Alas, distracted by his going on vacation this very afternoon, he forgets to add "World" to the list before starting the iteration. Trying to correct his mistake, he adds it a few lines later, but now his code unexpectedly breaks down at runtime ("this must be a JVM bug !").

A few minutes before leaving, he asks you to find a solution in his absence, with the following instructions :

• Do not modify his existing code, it's Perfect (of course).
• The FIXME tag shows where you're allowed to insert your corrective code
• He must be able to understand your solution when he comes back (so

using Reflection is not an option).

Are you worth the trust of your beloved Manager ?

final List<String> list = new ArrayList<String>() {{ add("Hello"); }};
final Iterator<String> iterator = list.iterator();
System.out.println(iterator.next());
list.add("World"); 
// FIXME : work here while I'm sunbathing
System.out.println(iterator.next());

Hints - Keep in mind that :

• the iterator is declared final
• this is only a code fragment, so you cannot use System.exit(0) or return; you wouldn't like your application to terminate prematurely, would you ?
• since you cannot modify the existing code, you cannot delete or ignore the last line, which must print "World"

Note : I must thank Romain Revol for helping me to write this quiz. Romain successfully attended the "Heinz Kabutz's Java Specialist Master Course" training session I presented in France in June at Zenika's office.

If you're not getting your athletic body's tanned on a beach this week, here is a small quiz to keep your brain fit.
What does this code snippet do ?

public class Quiz39 {
 
    public static void main(String[] args) {
        int[] array = null;
        try {
            array[0] = array[(array = createArray())[array.length - 1]];
        } finally {
            System.out.println("Array = " + Arrays.toString(array));
        }
    }
 
    public static int[] createArray() {
        return new int[]{1, 2, 3, 4};
    }
 
}

Can you help the poor Exception to escape the Matrix ?
Beware, the Agents are nearby and will spot you if you attempt in any way to modify or remove the existing lines of code ! (but you may add new ones).

public class Matrix {
    public static void getTheSpoon() {
        throw new java.lang.NoSuchMethodException("There is no spoon !");
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            Matrix.getTheSpoon();
        } catch (Exception ex) {
            System.out.println(ex instanceof java.lang.NoSuchMethodException ? "You passed the Quiz !" : "You failed !");
        }
    }
}

Voici un nouveau quiz, pour bien finir le mois de mai avant d'entamer ce beau mois de juin.

La classe ColoredPoint ci-dessous pose un problème assez subtil. Lequel ?

public class Point {
    private int x;
    private int y;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof Point)) { return false; }
 
        final Point point = (Point) o;
        return (x == point.x && y == point.y);
    }
 
    public int hashCode() {
        int result = x;
        result = 31 * result + y;
        return result;
    }
}
 
public class ColoredPoint extends Point {
    private Color color;
 
    public ColoredPoint(int x, int y, Color color) {
        super(x, y);
        this.color = color;
    }
 
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof ColoredPoint && super.equals(o))) {
            return false;
        }
 
        final ColoredPoint point = (ColoredPoint) o;
        return (color == null ? (point.color == null) : color.equals(point.color));
    }
 
    public int hashCode() {
        int result = super.hashCode();
        result = 31 * result + (color != null ? color.hashCode() : 0);
        return result;
    }
}

Pour créer des instances de classes dont on ne connait que le nom, rien de plus facile : il suffit de récupérer l'instance de Class<?> puis d'appeler newInstance() dessus, et puis de traiter les nombreuses exceptions susceptibles d'être levées.

C'est ce que fait la méthode statique newInstance ci-dessous :

public class TestNewInstance {
    public static void main(String[] args) {
        final Object o = newInstance(args[0]);
        System.out.println(String.valueOf(o));
    }
 
    private static Object newInstance(String className) {
        try {
            Class<?> clazz = Class.forName(className);
 
            return clazz.newInstance();
        } catch (ClassNotFoundException e) {
            System.out.println("-- Class Not Found --");
        } catch (IllegalAccessException e) {
            System.out.println("-- Illegal Access --");
        } catch (InstantiationException e) {
            System.out.println("-- Cannot Instantiate --");
        }
        return null;
    }
}

Bien sûr, la classe en question doit posséder un constructeur sans argument ; si ce n'est pas le cas, InstantiationException sera levée.

Cependant, malgré toutes ces précautions, ce code pose un gros problème de robustesse, qui ne se révèle que pour quelques classes bien particulières. Pourquoi ? Comment l'éliminer ?

Depuis une classe tierce, comment afficher la valeur du champ "message" de la classe ci-dessous ?
Il est naturellement interdit de court-circuiter les règles de visibilité des champs de la classe.

package net.thecodersbreakfast.quiz35
public class OuterClass {
 
	private String message = "Hello World";
 
	private class InnerClass {
		private String getMessage() {
			return message;
		}
	}
}

Vous savez qu'au sein de la JVM, une classe est identifiée de manière unique par son nom complet et son classloader.

Cette règle est facile à implémenter sous la forme d'une méthode utilitaire :

public class ClassUtils {
	public static boolean isSameClass(Class<?> class1, Class<?> class2) {
		if ((class1 == null) || (class2 == null)) { return false; }
		return (
			class1.getClassLoader().equals(class2.getClassLoader()) && 
			class1.getName().equals(class2.getName()) );
	}
}

Il ne reste plus qu'à vérifier :

System.out.println( ClassUtils.isSameClass(ClassUtils.class, ClassUtils.class) ); // true
System.out.println( ClassUtils.isSameClass(String.class, ClassUtils.class) ); // false

A moins que... ?

La classe ci-dessous part d'une bonne intention, mais où est le problème ?

/**
 * Garantit que les éventuelles exceptions levées par la méthode dangereuse
 * seront loggées.
 * @param <R> Le type de retour de la méthode
 * @param <E> Le type d'exception levé
 */
public abstract class ExceptionLoggingExecutor<R, E extends Throwable> {
 
	private final Logger logger = Logger.getLogger(ExceptionLoggingExecutor.class.getName());
 
	public final R execute(Object... args) throws E {
		try {
			return dangerousOperation(args);
		} catch (E e) {
			logger.error(e);
			throw e;
		}
	}
 
	/** La méthode contenant le code dangereux */
	protected abstract R dangerousOperation(Object... args) throws E;
}

Voici un quiz spécial saint-Valentin ! Comme d'habitude, il s'agit de trouver ce qui cloche avec ce code, sans le coller dans un IDE.

Comme le code est un peu plus long que d'habitude, il est exceptionnellement dans le corps du billet.
Bon quiz !