Was macht das Schlüsselwort 'new' in Java und sollte ich vermeiden, neue Objekte zu erstellen?

Ja, wenn Sie myMethod() 10 Mal aufgerufen haben, werden 10 eindeutige und separate Objekte erstellt.

Das Schlüsselwort new macht genau das, was es verspricht, es erstellt ein brandneues Objekt, unabhängig davon, ob eines bereits existiert. Es erstellt ein neues Objekt und stopft den Verweis auf dieses Objekt in die Variable, die es erhalten hat, wobei jeder vorherige Wert (Objekt) überschrieben wird, den die Variable gehalten hat.

Wird die Variable MyObject jedes Mal neu zugewiesen?

Ja, es würde bei jedem Aufruf der Methode mit einem neuen Objekt neu zugewiesen. Ein interessanter Hinweis dazu wäre, dass die Variable nicht „wirklich“ neu zugewiesen wird, wenn Sie die Variable innerhalb des Methodenkörpers selbst definieren. Es werden also tatsächlich 10 einzelne Variablen erstellt und 10 einzelne Objekte zugewiesen, obwohl, wie gesagt, die anderen automatisch entfernt werden sollten, damit kein zusätzlicher Speicher verwendet wird.

Auf den Punkt gebracht: sollte ich solchen Code nur schreiben, wenn ich diese Methode nur einmal aufrufen möchte?

Wie gesagt, im obigen Beispiel würde jedes Objekt am Ende der Methodenausführung zerstört (vorausgesetzt, Sie haben den Objektverweis nicht einer Variablen außerhalb des Gültigkeitsbereichs der Methode zugewiesen) In Ihrem Beispiel könnten Sie die Methode gerne so oft aufrufen, wie Sie möchten, aber jedes Mal in keiner Weise mit den vorherigen Aufrufen verbunden sein.

Mir ist klar, dass meine Schreibweise verwirrend sein kann.

‚Warum nicht FileWriter, FileReader, BufferedReader und BufferedWriter an der Spitze der Klasse deklarieren, wie sie es für die anderen Variablen getan haben?‘

Okay, ich nehme an, Sie verstehen, dass die Variablen nicht wirklich aufgerufen werden FileWriter, FileReader, BufferedReader, und BufferedWriter, sondern dies ist der Variablentyp. Ihre Namen sind fw, fr, br, und bw. Wenn Sie nicht verstehen, was ich meine, fragen Sie einfach. Von nun an werde ich die Variablen mit den Namen bezeichnen, die Sie getan haben, um das Lesen zu erleichtern, schließlich steht fw sowieso nur für FileWriter, also sollte es nicht zu viel Verwirrung geben.

Der Schlüssel zu dieser Frage ist in den Namen der Variablen selbst verborgen. Beachten Sie, wie sie entweder in Reader oder Writer Dies kann uns einen subtilen Hinweis auf ihre Verwendung geben. Offensichtlich haben FileWriter und BufferedWriter in irgendeiner Weise mit der Ausgabe zu tun. Wenn wir uns den Code ansehen, sehen wir, dass unser Verdacht richtig war und dass diese Variablen zu keinem anderen Zeitpunkt als innerhalb der writeText(JTextArea area) -Methode erscheinen. Wenn die Variablen also nirgendwo anders im Code verwendet werden, wäre es logisch, sie innerhalb der Methode, in der sie verwendet werden, zu definieren und zu initialisieren, was nicht nur das Lesen des Codes erleichtert, da wir dann „wissen“, dass diese Variablen nur mit dieser Methode zusammenhängen, sondern auch den Vorteil haben, dass diese Variablen am Ende der Methodenausführung entfernt werden, wodurch keine Variablen vorhanden bleiben, die nur sehr kurz verwendet wurden. Nach diesen Regeln können wir sagen, dass dasselbe für FileReader und BufferedReader gilt.

Beachten Sie dieses Beispiel für den Variablenbereich. (Schauen Sie sich die Kommentare an, die ich dem Code hinzugefügt habe)

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

Aus diesem Beispiel wird deutlicher, warum die Variablen in den Methoden und nicht als Instanzvariablen definiert und im Konstruktor initialisiert werden. Es ermöglicht viel saubereren Code und ist lesbarer.

Warum jedes Mal, wenn die Methode aufgerufen wird, anstatt vielleicht dieselbe Instanzvariable zu verwenden?

Nun, diese Frage hat mit Variablentypen zu tun. Wir konnten keine einzige Variable für alle Informationen wiederverwenden, da die Typen unterschiedlich sein müssten.

Wenn wir alle Variablen aus dem Code

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

Jetzt wissen wir, dass wir keinen Wert, der nicht vom selben Typ wie die Variable ist, in diese Variable einfügen können, also so etwas wie

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

Weil die Typen einfach nicht übereinstimmen.

Sinnvoll?