El siguiente código produce la salida "Hola mundo!" El siguiente código genera una salida "del mundo ¡Hola!" (NO para la verdad, la TI tratar). (No, en serio, probarlo).
public static void main(String... args) {
// The comment below is not a typo.
// \u000d System.out.println("Hello World!");
}
De ahí que el presente está en el análisis sintácticos en Los compilador de Java en el carácter Unicode \ como una nueva línea nueva y el se transforma en: La razón es que los caracteres Unicode de Java compilador se \ analizan como una nueva línea y se convierte en:
public static void main(String... args) {
// The comment below is not a typo.
//
System.out.println("Hello World!");
}
Por lo tanto resulta en un comentario de ser "ejecutados ". Comentarios resultantes fueron "ejecutados".
Se utiliza para el presente puede funcionar ya que "ocultar" código malicioso o concebir Cualquiera que sea un mal programador puede, ¿por qué es permitido en los comentarios ? Debido a que puede ser utilizado para cualquier cosa "oculta" de códigos maliciosos o programadores maliciosos pueden concebir por qué los comentarios permitirlo ?
¿Por qué esta permitido por la especificación de Java ? Especificación de Java ¿Por qué permitir esto?
# 1 planta
Casa # 2
Decodificación tiene lugar el Unicode antes de cualquier OTRA léxica -. Search.com Unicode decodificación antes que cualquier otra traducción de palabras. La principal ventaja de esto es que hace que sea trivial para ir y venir entre ASCII y cualquier otra codificación. La principal ventaja de esto es que se puede alternar entre ASCII y cualquier otro tipo de código. Ni siquiera tiene que averiguar donde empiezan los comentarios y al final! Ni siquiera tiene que averiguar una revisión de las posiciones de inicio y fin!
Dicho de AS JLS Sección 3.3 del presente android.permission a la Fuente herramienta archivos basados cualquier ASCII El proceso: La Sección 3.3 JLS anteriormente, esto permite que la herramienta de procesamiento basado en cualquiera de la fuente ASCII:
[...] el lenguaje de programación Java en La norma especifica una forma de transformar un programa escrito en ASCII Unicode en un programa que cambia a una forma que pueda ser procesada por herramientas basadas en ASCII. [...] el lenguaje de programación Java especifica una el tipo de programas de conversión escritas en Unicode método estándar ASCII, el programa va a cambiar el programa puede ser en forma de herramientas basadas en ASCII para su procesamiento. [...] [...]
Esto da una garantía fundamental para la independencia de plataforma (independencia de los juegos de caracteres soportados) que siempre ha sido un objetivo clave para la plataforma Java. Esto proporciona una garantía fundamental para la independencia de la plataforma (la independencia con el apoyo conjunto de caracteres), que ha sido Java la plataforma de destino clave.
Ser capaz de escribir cualquier carácter Unicode en cualquier lugar en el archivo es una característica interesante, y especialmente importante en los comentarios, al documentar código. En idiomas no latinos para escribir los caracteres Unicode en cualquier lugar del archivo es una buena característica, al escribir el código que utiliza idiomas no latinos, especialmente importante en los comentarios. El hecho de que puede interferir con la semántica de una manera tan sutil es sólo una (lamentable) de efectos secundarios. Es de esta manera sutil interfiere con la semántica del hecho de que los únicos efectos (lamentable) laterales.
EN el este trampas son muchos allí Tema y Java Puzzlers de Joshua Bloch y Neal Gafter en The incluirse después de la Variante: En este tema hay muchos problemas, Joshua Bloch y Neal GDespués de Puzzlers Java incluyen variantes la siguiente:
Es este un programa legal de Java? Este es un programa Java legítimas? Si es así, ¿qué quiere imprimir? Si es así, ¿qué va a imprimir?
\p\u\b\l\i\c\ \ \ \ \c\l\a\s\s\ \U\g\l\y \{\p\u\b\l\i\c\ \ \ \ \ \ \ \s\t\a\t\i\c \v\o\i\d\ \m\a\i\n\( \S\t\r\i\n\g\[\]\ \ \ \ \ \ \a\r\g\s\)\{ \S\y\s\t\e\m\.\o\u\t \.\p\r\i\n\t\l\n\(\ "\H\e\l\l\o\ \w"\+ "\o\r\l\d"\)\;\}\}
(Este programa se vuelve a estar fuera un llano "Hello World" Programa.) (Este programa resultó ser un simple programa "Hola Mundo").
En la solución del rompecabezas, que señalan lo siguiente: En el proceso de resolución de un juego de puzzle en el que se señalan los siguientes:
En serio Más, Puzzle Sirve como se menciona en el presente para Reforzar las lecciones de tres a lo anterior: Unicode ESCAPES esencial son los cuando se necesita para insertar caracteres que no pueden ser representados en el cualquier otro en su programa Vía. Más en serio, este rompecabezas ayuda los tres primeros cursos de fortalecimiento lección: cuando se necesita para insertar un carácter no puede ser expresado de cualquier otro modo, se escapa Unicode son esenciales. Evitarlos en todos los demás casos. Evitarlos en todos los demás casos.
Fuente: Java: la ejecución de código en los comentarios?! Fuente: Java: ejecutar código en los comentarios? !
Casa # 3
La \ fuga termina debido a un comentario\\u\u003c/code> escapes are uniformly converted to the corresponding Unicode characters before the program is tokenized. \ 转义终止注释，因为\\u\u003c/code>转义在程序被标记化之前被统一转换为相应的Unicode字符。 You could equally use \W\W instead of // to begin a comment. 您也可以使用\W\W而不是//来开始评论。
This is a bug in your IDE, which should syntax-highlight the line to make it clear that the \ ends the comment. 这是IDE中的一个错误，它应该语法突出显示该行，以明确\ 结束注释。
This is also a design error in the language. 这也是语言中的设计错误。 It can't be corrected now, because that would break programs that depend on it. 它现在无法纠正，因为这会破坏依赖它的程序。 \\u\u003c/code> escapes should either be converted to the corresponding Unicode character by the compiler only in contexts where that "makes sense" (string literals and identifiers, and probably nowhere else) or they should have been forbidden to generate characters in the U+0000–007F range, or both. \\u\u003c/code>转义应该由编译器仅在“有意义”的字符串中转换为相应的Unicode字符（字符串文字和标识符，可能不在其他地方），或者它们应该被禁止在U + 0000-中生成字符007F范围，或两者兼而有之。 Either of those semantics would have prevented the comment from being terminated by the \ escape, without interfering with the cases where \\u\u003c/code> escapes are useful—note that that includes use of \\u\u003c/code> escapes inside comments as a way to encode comments in a non-Latin script, because the text editor could take a broader view of where \\u\u003c/code> escapes are significant than the compiler does. 这些语义中的任何一个都会阻止注释被\ 转义终止，而不会干扰\\u\u003c/code>转义符有用的情况 - 请注意，这包括在注释中使用\\u\u003c/code>转义作为在非转义中编码注释的方法-Latin脚本，因为文本编辑器可以更广泛地了解\\u\u003c/code>转义比编译器更重要的地方。 (I am not aware of any editor or IDE that will display \\u\u003c/code> escapes as the corresponding characters in any context, though.) （我不知道任何编辑器或IDE会在任何上下文中显示\\u\u003c/code>转义为相应的字符。）
There is a similar design error in the C family, 1 where backslash-newline is processed before comment boundaries are determined, so eg 在C系列中存在类似的设计错误， 1其中在确定注释边界之前处理反斜杠换行符，例如
// this is a comment \
this is still in the comment!
I bring this up to illustrate that it happens to be easy to make this particular design error, and not realize that it's an error until it is too late to correct it, if you are used to thinking about tokenization and parsing the way compiler programmers think about tokenization and parsing. 我提出这个问题来说明这个特定的设计错误很容易发生，并且如果你习惯于考虑标记化和解析编译程序员的思维方式，那么直到修正它为时已经太晚才会发现它是错误的。关于标记化和解析。 Basically, if you have already defined your formal grammar and then someone comes up with a syntactic special case — trigraphs, backslash-newline, encoding arbitrary Unicode characters in source files limited to ASCII, whatever — that needs to be wedged in, it's easier to add a transformation pass before the tokenizer than it is to redefine the tokenizer to pay attention to where it makes sense to use that special case. 基本上，如果你已经定义了你的形式语法，然后有人想出一个语法特殊情况 - trigraphs，反斜杠换行，在源文件中编码任意Unicode字符，限制为ASCII，无论什么 - 需要楔入，它更容易在令牌化器之前添加转换传递，而不是重新定义令牌化器以注意使用该特殊情况的合理位置。
1 For pedants: I am aware that this aspect of C was 100% intentional, with the rationale — I am not making this up — that it would allow you to mechanically force-fit code with arbitrarily long lines onto punched cards. 1对于学龄儿童：我知道C的这个方面是100％有意识的，理由是 - 我不是这样做的 - 它可以让你用任意长线机械强制编码代码到打孔卡上。 It was still an incorrect design decision. 这仍然是一个不正确的设计决定。
# 4 piso
Estoy de acuerdo con @zwol que esto es un error de diseño; estoy de acuerdo @zwol esto es un error de diseño; . Sin embargo, el incluso el que soy más crítico de TI , pero estoy aún más crítica de la misma.
\\u\u003c/code> escape is useful in string and char literals; \\u\u003c/code>转义在字符串和字符文字中很有用; and that's the only place that it should exist. 这是唯一应该存在的地方。 It should be handled the same way as other escapes like \\n ; 它应该像其他转义一样处理，如\\n ; and "\ " should mean exactly "\\n" . 而"\ " 应该恰好代表"\\n" 。
There is absolutely no point of having \\uxxxx in comments - nobody can read that. 绝对没有\\uxxxx在评论中使用\\uxxxx - 没有人可以阅读。
Similarly, there's no point of using \\uxxxx in other part of the program. 同样，在程序的其他部分使用\\uxxxx也没有意义。 The only exception is probably in public APIs that are coerced to contain some non-ascii chars - what's the last time we've seen that? 唯一的例外可能是在强制包含一些非ascii字符的公共API中 - 我们最后一次看到它是什么？
The designers had their reasons in 1995, but 20 years later, this appears to be a wrong choice. 设计师在1995年有他们的理由，但20年后，这似乎是一个错误的选择。
(question to readers - why does this question keep getting new votes? is this question linked from somewhere popular?) （向读者提问 - 为什么这个问题不断获得新的选票？这个问题是否从流行的地方联系起来？）
Casa # 5
Como esto no ha abordado sin embargo, aquí una explicación, ¿por qué la traducción de Unicode escapa ocurre antes de cualquier otro procesamiento código fuente: Debido a resolver, hay una explicación de por qué se escapó conversión de Unicode se produce antes de cualquier otro procesamiento de código fuente:
La idea detrás de esto es que permite que las traducciones de código fuente de Java entre diferentes codificaciones de caracteres sin pérdidas. Es la idea detrás de esto es que permite entre diferentes codificaciones de caracteres sin pérdidas traducida código fuente de Java. Hoy en día, existe un amplio apoyo de Unicode, y esto no se ve como un problema, pero en aquel entonces no era fácil para un desarrollador de un país occidental para recibir algo de código fuente de su colega de Asia que contiene caracteres asiáticos, hacer algunos cambios ( incluyendo la compilación y prueba de ello) y el envío de la parte posterior resultado, todo ello sin dañar algo. hoy en día, existe un amplio soporte para Unicode, lo que no parece un problema, pero cuando los desarrolladores recibieron algunos países occidentales de Asia incluye a su colega de Asia el carácter del código fuente no es fácil de hacer algunos cambios (incluyendo la compilación y la prueba y los resultados enviados de vuelta, todo ello sin daños.
SO, Java puede ser código fuente escrito en el cualquier codificación y android.permission en un amplio rango de identificadores de caracteres, y Carácter String. Comentarios sobre los literales es y , por lo tanto, el código fuente de Java pueden ser escritos en cualquier codificación y el permiso identificador, el carácter y Stringel texto y anotación diversos personajes. Entonces, con el fin de transferirlo sin pérdidas , todos los caracteres no soportados por el objetivo de codificación se sustituyen por su Unicode escapa. Luego, con el fin de transferir su no destructiva, el objetivo de codificación no es compatible con todos los caracteres Unicode se reemplazan con su escape.
Este es un proceso reversible y la interesante cuestión es que la traducción se puede hacer mediante una herramienta que no necesita saber nada acerca de la sintaxis del código fuente de Java como la regla de conversión no depende de él. Este es un proceso reversible, Curiosamente, la conversión se puede hacer a través de una herramienta que no necesita saber nada acerca de la sintaxis del código fuente de Java, ya que las reglas de conversión no dependen de ella. Esto funciona la traducción de sus actuales caracteres Unicode dentro del compilador pasa de forma independiente a la sintaxis del código fuente de Java también. Esto se aplica a interno del compilador conversión real de caracteres Unicode es también independiente de la sintaxis del código fuente de Java. Esto implica que puede realizar una arbitraria número de pasos de traducción en ambas direcciones sin tener que cambiar el significado del código fuente. Esto significa que puede realizar cualquier número de pasos de conversión en ambas direcciones sin cambiar el código fuente de sentido.
Otro está en la razón de la presente extraño que no haya la incluso la característica mencionada: En la \\uuuuuuxxxxsintaxis: Esta es otra característica extraña, la razón ni siquiera se menciona: \\uuuuuuxxxxla sintaxis:
A - Herramienta Search.com está escapando los personajes y cuando se encuentra con una secuencia que es ya un ESCAPED secuencia, en caso de que un adicional de INSERT uen al de la secuencia, la conversión \쫾a \\uucafe. Cuando la herramienta de escape de traducción de caracteres y ya está experimentando una secuencia de escape, lo que debería se inserta en una secuencia adicional u, se \쫾convierte en \\uucafe. Es decir, no cambia en El, pero el al convertir en The en otras direcciones, por lo que deberían funcionar la herramienta de la opción Quitar el Justo uy las secuencias de reemplazar contienen sólo un único upor sus caracteres Unicode. Significado no cambia, pero al cambiar a otra dirección, la herramienta sólo debe una eliminación uy sustituciones de caracteres Unicode contiene sólo una única usecuencia. De esta manera, incluso escapes Unicode se retienen en su forma original. Al convertir de ida y vuelta de este tipo, será retenido en su forma original incluso en la parte trasera de escape Unicode adelante y hacia atrás. Supongo, nunca nadie usa esa característica ... Creo que nadie utiliza esta característica ......
Casa # 6
Esta fue una decisión de diseño intencional que va toda la manera de volver al diseño original de Java. Esta es una opción de diseño deliberada, Java ha sido devuelto al diseño original.
Para aquellas personas que preguntan "¿quién quiere Unicode se escapa en los comentarios?", Supongo que son personas cuyo idioma nativo utiliza el conjunto de caracteres latinos. Para aquellos que pide "que quieren escapar de la Unicode en los comentarios?" La gente, creo que son aquellos que usan la lengua materna conjunto de caracteres latinos. En otras palabras, es inherente al diseño original de Java que la gente podría utilizar caracteres Unicode arbitrarias siempre que sea legal en un programa Java, más típicamente en los comentarios y cadenas. En otras palabras, el original de Java inherente en el diseño, puede ser de Java cualquier lugar legítimo en el programa con cualquier carácter Unicode, el más común es en los comentarios y cadenas.
Podría decirse que es una deficiencia en los programas ( como IDE) que se utilizan para ver el texto original que tales programas no pueden interpretar los escapes Unicode y mostrar el signo correspondiente. Podemos decir que la desventaja para ver el texto original del programa (como IDE) es que estos programas escapa Unicode no pueden explicar y mostrar la forma correspondiente.
