new - ¿Código Java válido que NO es código válido de Groovy?

new icon java

Question

La mayoría del código Java también es sintácticamente válido para el código Groovy. Sin embargo, hay algunas excepciones que me llevan a mi pregunta:

¿Qué construcciones / características en Java son sintácticamente inválidas en Groovy? Proporcione ejemplos concretos de código Java (Java 1.6) que NO sea un código válido de Groovy (Groovy 1.6).

Actualizar:

Hasta ahora tenemos cinco ejemplos de código Java sintácticamente válido que no es válido código de Groovy:

1. Inicializaciones de matriz
2. Clases internas
3. def es una palabra clave en Groovy, pero no en Java
4. "$$" -strings - analizado como un GString no GString en Groovy
5. Bloques de inicialización no estáticos -- class Foo { Integer x; { x = 1; } } -- class Foo { Integer x; { x = 1; } }

¿Es esta la lista completa? ¿Algún otro ejemplo?

Actualización n. ° 1: comencé una recompensa para responder a esta pregunta. La recompensa se otorgará a la persona que proporcione la lista más completa de ejemplos. Hasta ahora hemos descubierto cinco ejemplos, pero estoy seguro de que hay un poco más allá. ¡Así que mantenlos en camino!

Answer 1

¿Alguien ha mencionado la diferencia en ==? Tomé esto de la documentación de Grails.

== significa igual en todos los tipos. En Java existe una parte extraña de la sintaxis donde == significa igualdad para tipos primitivos y == significa identidad para objetos.

Answer 2

Aquí hay una lista de elementos que son válidos para Java 6, pero no son válidos para Groovy 1.6. Esta no es una lista completa, pero creo que cubre la mayoría de los casos.

(Por cierto, creo que debería tener en cuenta que los bloques de inicialización no estáticos funcionan en Groovy).

Cualquier declaración de clase interna

incluyendo estático,

public class Outer{
  static class Inner{}
}

no estático,

public class Outer{
  class Inner{}
}

clases locales,

public class Outer{
  public static void main(String[] args) {
    class Local{}  
  }
}

y clases anónimas

java.util.EventListener listener=new java.util.EventListener(){};

Usar palabras clave de Groovy como variables

int def;
int in;
int threadsafe;
int as;

Array de inicialización

String[] stuff=new String[]{"string"};
int[] array={1,2,3};

Usar signos de dólar en cadenas donde lo que sigue no es una expresión válida

String s="$$";
String s="$def";
String s="$enum";
String s="$;";
String s="$//";
//etc.

Más de un inicializador en un bucle for

for (int i=0, j=0; i < 5; i++) {}

Más de un incremento en un bucle for

int j=0;
for (int i=0; i < 5; i++,j++) {}

Rompiendo algunas expresiones usando líneas nuevas

int a= 2 
/ 2 
;

Interruptor de finalización con una caja que no tiene cuerpo

switch(a){
  case 1:
}

Tener un valor predeterminado en un interruptor sin cuerpo

Se aplica en ambos casos donde el valor predeterminado es al final

int a=0;
switch(a){
    default:
}

o en algún lugar en el medio

switch(a){
    default:
    case 1:
        break;
}

Anotaciones con listas

@SuppressWarnings({"boxing","cast"})

Declaración de método nativo

public native int nativeMethod();

Clase por enum

public enum JavaEnum{
  ADD{
    public String getSymbol(){ return "+"; }
  };
  abstract String getSymbol();
}

Do loop

do{
  System.out.println("stuff");
}while(true);

Answer 3

Arrays multidimensionales, donde el tamaño no está especificado.

def x=new Object[5][];  // ERROR: expression expected 

def x=new Object[5][2]; // this works

Answer 4

Bloques de inicialización no estáticos:

class Foo {
  Integer x;   
  { x = 1; }
}

ACTUALIZACIÓN: Este es de hecho código Groovy válido.

Answer 5

Complementando la respuesta de Peter Dolberg:

Además del código válido de Java que no es válido en Groovy, también debe tener cuidado con el código que es válido tanto en Java como en Groovy, pero tiene resultados diferentes en Groovy. Ejemplos obvios son literales de caracteres y GStrings:

System.out.println(String.valueOf(''3'' + 3)); // 54 in Java, 33 in Groovy (arithmetic ascii value vs. String concat)

System.out.println("${3+4}");

Accionadores implícitos:

class Foo {public static int counter; public static int bar; public static void getBar() {counter++; return bar;}}
System.out.println(Foo.bar);
System.out.println(Foo.counter); // 0 in Java, 1 in Groovy

toString () ha sido sobrescrito por GroovyDefaultMethods, lo que puede morderte al analizar el resultado.

Map someMap = new HashMap();
someMap.put("a", "b")
someMap.toString();

La operación igual

"foo" == "foo"
class Foo {public boolean equals() {return true;}}
new Foo() == new Foo()

Alguna precedencia del operador:

a *= b/100; // Groovy: (a *= b)/100; Java: a *= (b/100);

Esta no es una respuesta correcta a la pregunta original, ya que el código groovy sigue siendo sintácticamente válido en sí mismo, pero dado que tiene un resultado diferente, creo que vale la pena mencionarlo aquí. El resultado es que, algorítmicamente, un método puede devolver el resultado incorrecto (no válido) cuando se copia de Java a Groovy.

Answer 6

Declarar una matriz de un tipo dado usando [] después del nombre de la variable en lugar del tipo funciona en Java pero no en Groovy.

byte[] buff = new byte[1024]; // Works

byte buff[] = new byte[1024]; // Not Groovy

Resultados en tipo primitivo literal: byte no se puede utilizar como nombre de método

Answer 7

Ok, aquí hay un punto:

int[] i = { 0, 1, 2 };

Esa es una buena sintaxis en java, mala en groovy.

No creo que quieras suponer que un código Java dado será equivalente en Groovy. Este sitio describe algunas de las diferencias, que incluye cosas tan básicas como == que no significa lo mismo en ambos idiomas. Además, la inicialización de la matriz estática es diferente, y no hay clases internas anónimas.

Esto compila bien en Java 1.6

public class Test2 {
    int[] i = { 0, 1, 2 };

    private class Class1 {
        public void method1() {
            if (i[2] == 2) {
                System.out.println("this works");
            }
        }
    }

    public void method1() {
        Class1 class1 = new Class1();
        class1.method1();
    }
}

Pero está tan mal en Groovy. Da los siguientes errores en Groovy 1.6:

unexpected token: 1 @ line 2, column 14.

Class definition not expected here. Possible attempt to use inner class. Inner classes not supported, perhaps try using a closure instead. at line: 4 column: 2.

Si arreglas esas cosas, sin embargo, imprime lo que esperas.

Si está buscando problemas de sintaxis de lenguaje más nuevos, como genéricos o anotaciones, Groovy admite ambos, aunque no del todo.

Answer 8

Todo lo que puedo pensar por ahora:

• int def;
• String s = "$$";