Vad gör nyckelordet'nytt ' faktiskt i Java, och ska jag undvika att skapa nya objekt?

Ja, om du ringde myMethod() 10 gånger kommer det att skapa 10 unika och separata objekt.

nyckelordet new gör exakt vad det står på tin, det skapar ett helt nytt objekt, oavsett om det redan finns. Det skapar ett nytt objekt och fyller referensen till det objektet i variabeln det har givits och skriver över alla tidigare värden (objekt) variabeln som hålls.

omfördelas myobject-variabeln varje gång?

återigen, ja det skulle omfördelas med ett nytt objekt varje gång metoden kallades. En intressant anteckning om detta skulle vara att variabeln inte skulle ”riktigt” omfördelas när du definierar variabeln inom själva metodkroppen, så varje gång metoden slutar kommer den att ta bort variablerna som definierades inom dess omfattning. Så vad det faktiskt gör är att skapa 10 enskilda variabler och tilldela 10 enskilda objekt, men som jag sa borde de andra ha tagits bort automatiskt så att det inte skulle använda något extra minne.

i ett nötskal: ska jag bara skriva kod så om jag bara planerar att åberopa den metoden en gång?

Tja, som jag sa, i exemplet ovan skulle varje objekt förstöras i slutet av metodkörningen (förutsatt att du inte tilldelade objektreferensen till en variabel utanför metodens omfattning) så i ditt exempel kan du gärna ringa metoden så många gånger du ville men varje gång skulle inte på något sätt kopplas till tidigare samtal.

jag inser att mitt sätt att skriva kan vara förvirrande, så om du vill att jag ska klargöra någonting, fråga bara.

’ varför inte deklarera FileWriter, FileReader, BufferedReader och BufferedWriter högst upp i klassen som de gjorde för de andra variablerna?’

Okej, Jag antar att du förstår att variablerna faktiskt inte kallas FileWriter, FileReader, BufferedReader, och BufferedWriter, men det här är variabeltypen. Deras namn är fw, fr, br, och bw. Om du inte förstår vad jag menar, fråga bara. Från och med nu kommer jag att hänvisa till variablerna med namnen du gjorde för att göra läsningen lättare, trots allt fw står bara för FileWriter ändå så det borde inte vara för mycket förvirring.

nyckeln till denna fråga är dold inom namnen på variablerna själva. Lägg märke till hur de antingen slutar i Reader eller Writer detta kan ge oss en subtil ledtråd om deras användning. Klart FileWriter och BufferedWriter har att göra med produktionen på något sätt. Genom att titta över koden ser vi att våra misstankar var rätt och att dessa variabler inte på något annat sätt än inom writeText(JTextArea area) – metoden visas. Så om variabeln inte används någon annanstans inom koden skulle det vara logiskt att definiera och initiera dem inom den metod som de används i, gör det inte bara koden lättare att läsa eftersom vi då ”vet” att dessa variabler bara är relaterade till den metoden, men har också fördelen att de variablerna tas bort i slutet av metodkörningen och därmed inte lämnar variabler som bara användes mycket kort. Genom dessa regler kan vi säga detsamma gäller för FileReader och BufferedReader.

observera detta exempel om variabel omfattning. (Titta på kommentarerna jag lagt till koden)

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

från detta exempel blir det tydligare varför variablerna definieras i metoderna snarare än som instansvariabler och initieras inom konstruktören. Det möjliggör mycket renare kod samt att vara mer readabe.

Varför gör det varje gång metoden kallas snarare än att använda kanske samma instansvariabel?

Tja, den här frågan har att göra med variabla typer. Vi kunde inte återanvända en enda variabel för all information eftersom typerna skulle ha behövt vara olika.

om vi tar alla variabler från koden

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

nu vet vi att vi inte kan placera ett värde som inte är av samma typ som variabeln i den variabeln så något som

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

eftersom typerna helt enkelt inte matchar.

vettigt?