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... ;-)

Bon, je reconnais, ce code est assez abscons, mais dans la vie, on ne rencontre pas toujours des codes idéalement écrits. Il peut donc être utile de savoir quoi faire dans ce type de situation.

Procédons par étapes.

Tout d'abord, un peu de reformatage ne ferait pas de mal à un code aussi horrible :

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)));
        }
    }
}
 

C'est mieux, mais ce n'est pas encore ça.

Mais n'oublions pas que, selon la JLS (3.2), tous les caractères saisis sous la forme d'une séquence Unicode sont remplacés avant toute autre étape de compilation par le caractère réel. Ici, nous avons clairement de quoi rendre plus lisible notre classe :

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

On découvre alors qu'il y avait des commentaires ! Supprimons-les derechef :

class Koassah{
    public static void main(String[] args){
        for(int $:"m¾\"®Æ¤¾\u01b0¤´È:\"À¾\"ª´Ê\"\u0138iÀ¼¼¬¾Ê\"`\u0158".toCharArray()) {
            System.out.print((char)(($>>+(~'"'&'#'))+('<'>>('\\'/'.'))));
        }
    }
}

Ici, petite surprise : on reconnaît bien une boucle for, mais sa variable s'appelle $ ! Et Java ne dit rien ! Et oui, d'après la JLS (3.8) (pour des raisons historiques, dit-elle) le caractère $ fait partie des caractères autorisés pour les identifiants.

Notons au passage que les autres symboles monétaires sont considérés comme des lettres ; on peut donc les utiliser dans des identificateurs :

private String $Dollar;  // Toutes ces lignes compilent sans erreur
private String £Pound;
private String €Euro;
private String ¥Yen;
private String ¢Cent;
private String \u20a3Franc;
private String \u20a4Lira;
private String \u20aaNewShekel;
private String \u20a7Peseta;
private String \u20abDong;
private String ¤Currency;
private String \u03c0SmallGreekPi;  // Les lettres des autres alphabets sont acceptées elles aussi...
private String \u05d0HebraicAlef;
private String \u2113RoundL;
private String µMicro;                // Même les éléments d'unités physiques sont utilisables !
private String \u2126Ohm;

D'autres symboles ne sont pas considérés comme des lettres, et le compilateur Java les refuse :

private String ©Copy;  // Toutes ces lignes compilent avec une erreur "illegal character"
private String ®Registered;
private String §Paragraph;
private String ¬Not;
private String ±MoreOrLess;
private String ¦DashedVerticalBar;
private String ¡InvertedExclamation;
private String ¿InvertedQuestion;
private String \u2122TradeMark;
private String \u221aSquareRoot;
private String \u221eInfinite;
private String \u2640Female;
private String \u2642Male;
private String \u263aSmile;
private String \u2105CareOf;
private String \u2116Number;

Renommons donc notre variable $ avec un nom un brin plus compréhensible pour un humain, et profitons-en pour agrémenter le code de quelques espaces ici et là :

class Koassah {
    public static void main(String[] args) {
        for (int caractere : "m¾\"®Æ¤¾\u01b0¤´È:\"À¾\"ª´Ê\"\u0138iÀ¼¼¬¾Ê\"`\u0158".toCharArray()) {
            System.out.print((char) ((caractere >> + (~ '"' & '#')) + ('<' >> ('\\' / '.'))));
        }
    }
}

Voilà qui devient plus clair : on prend une chaîne de caractères, et, pour chacun des caractères, on applique un petit traitement numérique sur son code Unicode. Notons au passage que toCharArray() renvoie un tableau de caractères, mais que la variable de boucle est déclarée de type int. Sans que cela ne provoque d'erreur de la part du compilateur.

Sinon, une idée sur ce traitement numérique ?

Déjà, si on remplaçait les caractères du calcul par leur code, puisqu'en fait, on fait des calculs sur des entiers, ce serait plus clair :

class Koassah {
    public static void main(String[] args) {
        for (int caractere : "m¾\"®Æ¤¾\u01b0¤´È:\"À¾\"ª´Ê\"\u0138iÀ¼¼¬¾Ê\"`\u0158".toCharArray()) {
            System.out.print((char) ((caractere >> + (~ 34 & 35)) + (60 >> (92 / 46))));
        }
    }
}

Et la simplification devient alors aisée :

class Koassah {
    public static void main(String[] args) {
        String message = "m¾\"®Æ¤¾\u01b0¤´È:\"À¾\"ª´Ê\"\u0138iÀ¼¼¬¾Ê\"`\u0158";
 
        for (int caractere : message.toCharArray()) {
            System.out.print((char) ((caractere >> 1) + 15));
        }
    }
}

Du coup, il est facile de savoir ce qu'affiche ce programme, en prenant le code de chaque caractère, en le transformant, et en en déduisant le caractère transformé :

109 -->  69 = E
190 --> 110 = n
 34 -->  32 =  
174 --> 102 = f
198 --> 114 = r
164 -->  97 = a
190 --> 110 = n
432 --> 231 = ç
164 -->  97 = a
180 --> 105 = i
200 --> 115 = s
 58 -->  44 = ,
 34 -->  32 =  
192 --> 111 = o
190 --> 110 = n
 34 -->  32 =  
170 --> 100 = d
180 --> 105 = i
202 --> 116 = t
 34 -->  32 =  
312 --> 171 = «
105 -->  67 = C
192 --> 111 = o
188 --> 109 = m
188 --> 109 = m
172 --> 101 = e
190 --> 110 = n
202 --> 116 = t
 34 -->  32 =  
 96 -->  63 = ?
344 --> 187 = »

Autrement dit : "En français, on dit «Comment ?»" (hé oui, dire « Koassah ?», ce n'est guère distingué... :-) )

Finalement, ce n'était pas si difficile !

Mais cela nous a permis de nous souvenir de trois choses :

• Le compilateur remplace automatiquement les séquences Unicode dans le code Java, toujours avant d'effectuer quoi que ce soit d'autre.
• Le caractère $ est un caractère valide (quoique peu recommandable) au sein d'un identifiant Java.
• Malgré leur typage différent, les caractères sont manipulables comme des types entiers.

Et voilà !