Mit csinál valójában a' new ' kulcsszó a Java-ban, és kerüljem az új objektumok létrehozását?

Igen, ha myMethod() 10-szer hívta, akkor 10 egyedi és különálló objektumot hoz létre.

a new kulcsszó pontosan azt teszi, amit a tin-en mond, vadonatúj objektumot hoz létre, függetlenül attól, hogy létezik-e már. Létrehoz egy új objektumot, és kitölti az adott objektumra való hivatkozást a megadott változóban, felülírva a változó korábbi értékét (objektumát).

a myObject változó minden alkalommal újraelosztásra kerül?

ismét igen, minden alkalommal, amikor a metódust meghívták, újra kiosztják egy új objektummal. Érdekes megjegyzés erről az lenne, hogy a változót nem “igazán” osztanák át, mivel a változót maga a módszertestben határozza meg, tehát minden alkalommal, amikor a módszer véget ér, eltávolítja a ” hatókörén belül meghatározott változókat. Tehát valójában 10 egyedi változót hoz létre és 10 egyedi objektumot rendel hozzá, bár ahogy mondtam, a többit automatikusan el kellett volna távolítani, hogy ne használjon további memóriát.

dióhéjban: csak akkor írjak ilyen kódot, ha csak egyszer tervezem meghívni ezt a módszert?

nos, mint mondtam, a fenti példában minden objektum megsemmisül a metódus végrehajtásának végén (feltételezve, hogy nem rendelte hozzá az objektum hivatkozást a metódus hatókörén kívül eső változóhoz), így a példában boldogan hívhatja a metódust annyiszor, amennyit csak akart, de minden alkalommal semmilyen módon nem kapcsolódna az előző hívásokhoz.

rájöttem, hogy az írásmódom zavaró lehet, ezért ha azt akarja, hogy tisztázzak valamit, csak kérdezzen.

‘miért nem deklaráljuk FileWriter, FileReader, BufferedReader és BufferedWriter a tetején az osztály, mint tették a többi változó?’

Oké, feltételezem, hogy megérti, hogy a változókat valójában nem hívják meg FileWriter, FileReader, BufferedReader, és BufferedWriter, de inkább ez a változó típusa. A nevük fw, fr, br, és bw. Ha nem érted, mire gondolok, csak kérdezz. Mostantól fogok hivatkozni a változókat a neveket tettél, hogy olvasás könnyebb, afterall fw csak áll a FileWriter egyébként így nem kell túl sok zavart.

ennek a kérdésnek a kulcsa a változók neveiben rejlik. Figyeljük meg, hogyan végződnek Reader vagy Writer ez finom nyomot adhat nekünk a felhasználásukról. Nyilvánvaló, hogy a FileWriter és a BufferedWriter valamilyen módon a kimenettel kapcsolatos. A kód áttekintésével azt látjuk, hogy a gyanúink helyesek voltak, és hogy a writeText(JTextArea area) módszeren kívül egyetlen ponton sem jelennek meg ezek a változók. Tehát, ha a változót sehol máshol nem használják a kódon belül, logikus lenne meghatározni és inicializálni őket abban a metódusban, amelyben használják őket, nemcsak megkönnyíti a kód olvasását, mert akkor “tudjuk”, hogy ezek a változók csak az adott metódushoz kapcsolódnak, hanem annak az előnye is, hogy ezeket a változókat eltávolítják a metódus végrehajtásának végén, ezáltal nem hagyva olyan változókat, amelyek csak nagyon rövid ideig használtak. Ezekkel a szabályokkal elmondhatjuk, hogy ugyanez igaz a FileReader és BufferedReaderesetekre is.

vegye figyelembe ezt a példát a változó hatókörről. (Nézd meg a megjegyzéseket, amelyeket hozzáadtam a kódhoz)

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

ebből a példából világossá válik, hogy a változókat miért definiálják a metódusokban, nem pedig példányváltozóként, és inicializálják a konstruktorban. Ez lehetővé teszi a sokkal tisztább kódot, valamint, hogy több readabe.

miért csinálja minden alkalommal, amikor a metódust meghívják, ahelyett, hogy talán ugyanazt a példányváltozót használná?

Nos, ez a kérdés a változó típusokhoz kapcsolódik. Nem használhattunk egyetlen változót az összes információhoz, mivel a típusoknak különbözniük kellett volna.

ha az összes változót a

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

kódból vesszük, akkor most már tudjuk, hogy nem helyezhetünk el olyan értéket, amely nem azonos típusú, mint a változó, tehát valami hasonló

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

mert a típusok egyszerűen nem egyeznek.

van értelme?