¿Qué hace realmente la palabra clave 'new' en Java, y debo evitar crear objetos nuevos?

Sí, si llamó a myMethod() 10 veces, creará 10 objetos únicos y separados.

La palabra clave new hace exactamente lo que dice en la lata, crea un objeto completamente nuevo, independientemente de si ya existe uno. Crea un nuevo objeto y añade la referencia a ese objeto dentro de la variable que se le ha dado, sobrescribiendo cualquier valor anterior (objeto) de la variable retenida.

¿La variable myObject se reasigna cada vez?

De nuevo, sí, se reasignaría con un nuevo objeto cada vez que se llamara al método. Una nota interesante sobre esto sería que la variable no se reasignaría «realmente» a medida que se define la variable dentro del cuerpo del método en sí, por lo que cada vez que finalice el método, eliminará las variables que se definieron dentro de su ámbito. Así que lo que realmente hace es crear 10 variables individuales y asignar 10 objetos individuales, aunque como dije, los demás deberían haberse eliminado automáticamente para que no usara memoria adicional.

En pocas palabras: ¿debo escribir código como ese solo si planeo invocar ese método una sola vez?

Bien, como dije, en el ejemplo anterior, cada objeto se destruiría al final de la ejecución del método (suponiendo que no asignara la referencia del objeto a una variable fuera del alcance del método), por lo que en su ejemplo podría llamar al método tantas veces como quisiera, pero cada vez no estaría conectado de ninguna manera a las llamadas anteriores.

Me doy cuenta de que mi forma de escribir puede ser confusa, así que si quieres que aclare algo, solo pídelo.

‘¿por qué no declarar FileWriter, FileReader, BufferedReader y BufferedWriter en la parte superior de la clase como lo hicieron para las otras variables?’

Bien, asumo que entiendes que las variables no se llaman realmente FileWriter, FileReader, BufferedReader, y BufferedWriter, sino que este es el tipo de variable. Sus nombres son fw, fr, br, y bw. Si no entiendes lo que quiero decir, solo pregunta. A partir de ahora, me referiré a las variables por los nombres que hizo para facilitar la lectura, después de todo fw solo significa FileWriter de todos modos, por lo que no debería haber demasiada confusión.

La clave de esta pregunta está oculta dentro de los nombres de las variables en sí. Observe cómo terminan en Reader o Writer, esto puede darnos una pista sutil sobre sus usos. Claramente FileWriter y BufferedWriter tienen que ver con la salida de alguna manera. Al revisar el código, vemos que nuestras sospechas eran correctas y que en ningún otro punto que no sea dentro del método writeText(JTextArea area) aparecen estas variables. Así que si la variable no se utiliza en ningún otro lugar dentro del código tendría sentido lógico para definir y seleccionarlos en el método que se utiliza en, no sólo hacer el código más fácil de leer porque luego «saber», las variables que están relacionadas con ese método, pero también tiene la ventaja de estas variables, siendo eliminado en la final de la ejecución del método, lo que no deja de variables en existencia que sólo se han utilizado muy brevemente. Por estas reglas podemos decir que lo mismo es cierto de FileReader y BufferedReader.

Observe este ejemplo sobre el alcance de la variable. (Mira los comentarios que agregué al código)

public class DataBase {private static String buf, retString = "\n"; // buf & retString - createdprivate static File file = new File("test.txt"); // file - createdpublic static void readText(JTextArea area) { try { FileReader fr = new FileReader (file); // fr (FileReader) - created BufferedReader br = new BufferedReader(fr); // br (BufferedReader) - created while ((buf = br.readLine()) != null) { area.append(buf); area.append(retString); } br.close(); fr.close(); } // fr (FileReader & br (BufferedReader) - destroyed catch (IOException e) { System.out.println("Exception: " + e); }}public static void writeText(JTextArea area) { try { FileWriter fw = new FileWriter (file); // fw (FileWriter) - created BufferedWriter bw = new BufferedWriter(fw); // bw (BufferedWriter) - created bw.write(area.getText()); bw.close(); fw.close(); } // fw & bw - destroyed catch (IOException e) { System.out.println("Exception: " + e); }}} // buf, retString and file - Still exist as long as the object exists

A partir de este ejemplo, queda más claro por qué las variables se definen en los métodos en lugar de como variables de instancia e inicializadas dentro del constructor. Permite un código mucho más limpio, además de ser más legible.

¿Por qué hacerlo cada vez que se llama al método en lugar de usar tal vez la misma variable de instancia?

Bueno, esta pregunta tiene que ver con tipos de variables. No pudimos reutilizar una sola variable para toda la información, ya que los tipos habrían tenido que ser diferentes.

Si tomamos todas las variables del código

private static String buf, retString = "\n"; // validprivate static File file = new File("test.txt"); // validFileReader fr = new FileReader (file); // validBufferedReader br = new BufferedReader(fr); // validFileWriter fw = new FileWriter (file); // validBufferedWriter bw = new BufferedWriter(fw); // valid

Ahora sabemos que no podemos colocar un valor que no sea del mismo tipo que la variable en esa variable, por lo que algo como

FileReader fr = new BufferedReader(fr); // Is not valid!

Porque los tipos simplemente no coinciden.

¿Tiene sentido?