queries - Tiene Java un equivalente a la cláusula C#"using"

jpa like

Question

He visto referencias en algunas de las preguntas publicadas de C # en una cláusula de "uso". ¿Java tiene el equivalente?

Answer 1

Creo que puedes lograr algo similar al bloque "usar", implementando una clase interna anónima. Como Spring lo hace con las "Plantillas Dao".

Answer 2

No que yo supiese. Puedes simular algo con un intento ... finalmente bloquear, pero todavía no es lo mismo.

Answer 3

No, no hay uso en Java, la funcionalidad más similar es la palabra clave "importar".

Answer 4

No, no hay.

Usted puede

public void func(){
{
ArrayList l = new ArrayList();
}
System.out.println("Hello");
}

Esto le da el alcance limitado de la cláusula de uso, pero no hay ninguna interfaz IDisposable para llamar al código de finalización. Puedes usar try {} catch () {} Finally {}, pero no tiene el azúcar de usar. Por cierto, el uso de finalizadores en Java generalmente es una mala idea.

Answer 5

Bueno, usar el azúcar sintáctico de todos modos, así que compañeros de Java, no te preocupes.

Answer 6

El equivalente más cercano dentro del idioma es usar try-finally.

using (InputStream in as FileInputStream("myfile")) {
... use in ...
}

se convierte

final InputStream in = FileInputStream("myfile");
try {
... use in ...
} finally {
in.close();
}

Tenga en cuenta que la forma general siempre es:

acquire;
try {
use;
} finally {
release;
}

Si la adquisición está dentro del bloque try, lo liberará en caso de que la adquisición falle. En algunos casos, es posible que puedas hackear código innecesario (por lo general, pruebas de null en el ejemplo anterior), pero en el caso de, por ejemplo, ReentrantLock, sucederán cosas malas.

Si haces lo mismo a menudo, puedes usar el modismo "ejecutar alrededor". Lamentablemente, la sintaxis de Java es prolija, por lo que hay una gran cantidad de placa más bolier.

fileInput("myfile", new FileInput<Void>() {
public Void read(InputStream in) throws IOException {
... use in ...
return null;
}
});

dónde

public static <T> T fileInput(FileInput<T> handler) throws IOException {
final InputStream in = FileInputStream("myfile");
try {
handler.read(in);
} finally {
in.close();
}
}

Ejemplo más complicado, por ejemplo, envolver excepciones.

Answer 7

Lo más cercano que puedes obtener en Java es try / finally. Además, Java no proporciona un tipo implícito desechable.

C #: determina el alcance de la variable fuera de un bloque de uso

public class X : System.IDisposable {
public void Dispose() {
System.Console.WriteLine("dispose");
}
private static void Demo() {
X x = new X();
using(x) {
int i = 1;
i = i/0;
}
}
public static void Main(System.String[] args) {
try {
Demo();
} catch (System.DivideByZeroException) {}
}
}

Java: determina el alcance de la variable fuera de un bloque

public class X {
public void dispose() {
System.out.println("dispose");
}
private static void demo() {
X x = new X();
try {
int i = 1 / 0;
} finally {
x.dispose();
}
}
public static void main(String[] args) {
try {
demo();
} catch(ArithmeticException e) {}
}
}

C #: explorando la variable dentro de un bloque

public class X : System.IDisposable {
public void Dispose() {
System.Console.WriteLine("dispose");
}
private static void Demo() {
using(X x = new X()) {
int i = 1;
i = i/0;
}
}
public static void Main(System.String[] args) {
try {
Demo();
} catch (System.DivideByZeroException) {}
}
}

Java: el alcance de la variable dentro de un bloque

public class X {
public void dispose() {
System.out.println("dispose");
}
private static void demo() {
{
X x = new X();
try {
int i = 1 / 0;
} finally {
x.dispose();
}
}
}
public static void main(String[] args) {
try {
demo();
} catch(ArithmeticException e) {}
}
}

Answer 8

Si obtenemos cierres BGGA en Java, esto también se abriría para estructuras similares en Java. Gafter ha utilizado este ejemplo en sus diapositivas, por ejemplo:

withLock(lock) { //closure }

Answer 9

El modismo real utilizado por la mayoría de los programadores para el primer ejemplo es este:

InputStream is1 = null;
InputStream is2 = null;
try{
is1 = new FileInputStream("/tmp/bar");
is2 = new FileInputStream("/tmp/foo");
/* do stuff with is1 and is 2 */
} finally {
if (is1 != null) {
is1.close();
}
if (is2 != null) {
is2.close();
}
}

Hay menos sangrado usando este modismo, que se vuelve aún más importante cuando tienes más de 2 recursos para la limpieza.

Además, puede agregar una cláusula catch a la estructura que tratará con el nuevo FileStream () lanzando una excepción si lo necesita. En el primer ejemplo, tendrías que tener otro bloque adjunto try / catch si quieres hacer esto.

Answer 10

Llegó mucho tiempo, pero con Java 7 , se agregó la declaración try-with-resources , junto con la interfaz AutoCloseable .

Answer 11

Sí. Java 1.7 introdujo la construcción try-with-resources que le permite escribir:

try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}

... solo como una declaración de using .

Desafortunadamente, antes de Java 1.7, los programadores de Java se vieron obligados a usar try {...} finally {...}. En Java 1.6:

InputStream is1 = new FileInputStream("/tmp/foo");
try{
InputStream is2 = new FileInputStream("/tmp/bar");
try{
/* do stuff with is1 and is 2 */
} finally {
is2.close();
}
} finally {
is1.close();
}

Answer 12

Sí, desde Java 7 puede reescribir:

InputStream is1 = new FileInputStream("/tmp/foo");
try{
InputStream is2 = new FileInputStream("/tmp/bar");
try{
/* do stuff with is1 and is2 */
} finally {
is2.close();
}
} finally {
is1.close();
}

Como

try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}

Los objetos pasados ​​como parámetros a la declaración try deberían implementar java.lang.AutoCloseable Consulte los documentos oficiales .

Para versiones anteriores de Java, compruebe esta respuesta y esta respuesta .