java - que - visual c#

Declaración CON en Java

Question

En VB.NET está el comando WITH que le permite omitir un nombre de objeto y acceder solo a los métodos y propiedades necesarios. Por ejemplo:

With foo
   .bar()
   .reset(true)
   myVar = .getName()
End With

¿Hay alguna sintaxis en Java?

¡Gracias!

Answer 1

Algunos objetos te permiten "invocar" invocaciones de métodos, lo que se acerca a la sintaxis que te gusta. Por ejemplo, a menudo una clase de generador se devolverá a sí misma de los métodos para que pueda hacer algo como esto:

MyObject b = new MyBuilder().setFoo(5).setBar(6).setBaz("garply!").build();

Cada set... método devuelve this para que pueda encadenar la siguiente invocación.

Answer 2

Como ya se dijo, realmente no se puede escribir el código como esto en Java.

Al igual que un comentario, si tiene miedo de copiar / pegar muchos en el caso de que necesite cambiar el nombre de la variable, Eclipse le permite cambiar el nombre de todas las referencias de la variable automáticamente:

Usando ALT + MAYÚS + R en el nombre de la variable "foo", puede cambiar el nombre de todos a la vez a "myFoo", por ejemplo:

Foo myFoo = new Foo();
myFoo.bar();
myFoo.reset(true);

Answer 3

Lo más parecido a esto son las importaciones estáticas que le permitirán llamar a métodos estáticos sin especificar explícitamente la clase en la que existe el método.

Answer 4

No. Lo mejor que puedes hacer, cuando la expresión es demasiado larga, es asignarla a una variable local con un nombre corto, y usar {...} para crear un alcance:

{
   TypeOfFoo it = foo; // foo could be any lengthy expression
   it.bar();
   it.reset(true);
   myvar = it.getName();
}

Answer 5

Nop. Java tiene una política de evitar todo lo que pueda reducir la verbosidad.

Bueno, después de escribir esto, se me ocurrió que lo más parecido podrían ser las importaciones estáticas, por ejemplo

package a.b.c.d;
public class Foo {
   public static void bar() {
      ...
   }
}

y ahora puedes hacer

package d.e.f;
import static a.b.c.d.Foo.*;

bar();

Answer 6

Puede acercarse bastante utilizando Java 8 lambdas, con el inconveniente de no poder modificar las variables locales.

Declara este método:

static <T> void with(T obj, Consumer<T> c) {
    c.accept(obj);
}

Entonces puedes usar:

Window fooBarWindow = new Window(null);

String mcHammer = "Can''t Touch This";

with(fooBarWindow, w -> {
     w.setAlwaysOnTop(true);
     w.setBackground(Color.yellow);
     w.setLocation(300, 300);

     w.setTitle(mcHammer); // can read local variables
     //mcHammer = "Stop!"; // won''t compile - can''t modify local variables
});

Esto también es posible usando una clase anónima, pero no tan limpia.

Answer 7

Tal vez la forma más cercana de hacer eso en Java es la expresión idiomática doble, durante la construcción.

Foo foo = new Foo() {{
    bar();
    reset(true);
    myVar = getName(); // Note though outer local variables must be final.
}};

Alternativamente, los métodos que devuelven this pueden estar encadenados:

myName =
    foo
        .bar()
        .reset(true)
        .getName();

donde la bar y los métodos de reset devuelven this .

Sin embargo, querer hacer esto tiende a indicar que el objeto no tiene un comportamiento lo suficientemente rico. Intente refactorizar en la clase llamada. Tal vez hay más de una clase tratando de salir.