Hvad gør nøgleordet 'nyt' faktisk i Java, og skal jeg undgå at oprette nye objekter?

Ja, Hvis du kaldte myMethod() 10 gange, vil det skabe 10 unikke og separate objekter.

nøgleordet new gør præcis, hvad der står på tin, det skaber et helt nyt objekt, uanset om man allerede eksisterer. Det skaber et nyt objekt og fylder henvisningen til det objekt inde i variablen, det er blevet givet, overskriver enhver tidligere værdi (objekt) variablen holdt.

er myobject-variablen omfordelt hver gang?

igen, ja det ville blive omfordelt med et nyt objekt hver gang metoden blev kaldt. En interessant note om dette ville være, at variablen ikke “virkelig” ville blive omfordelt, da du definerer variablen i selve metodekroppen, så hver gang metoden slutter, vil den fjerne de variabler, der blev defineret inden for dens anvendelsesområde. Så hvad det faktisk gør er at oprette 10 individuelle variabler og tildele 10 individuelle objekter, selvom de andre som sagt skulle have været fjernet automatisk, så det ikke ville bruge nogen ekstra hukommelse.

i en nøddeskal: skal jeg kun skrive kode sådan, hvis jeg kun planlægger at påberåbe mig denne metode en gang?

som jeg sagde, ville hvert objekt i eksemplet ovenfor blive ødelagt i slutningen af metodeudførelsen (forudsat at du ikke tildelte objektreferencen til en variabel uden for metodens omfang), så i dit eksempel kunne du med glæde kalde metoden så mange gange som du ville, men hver gang ville på ingen måde være forbundet med de tidligere opkald.

jeg er klar over, at min måde at skrive på kan være forvirrende, så hvis du vil have mig til at afklare noget, så spørg bare.

‘hvorfor ikke erklære Filskriver, fillæser, BufferedReader og Bufferedskriver øverst i klassen, som de gjorde for de andre variabler?’

Okay, jeg antager, at du forstår, at variablerne faktisk ikke kaldes FileWriter, FileReader, BufferedReader, og BufferedWriter , men det er snarere variabeltypen. Deres navne er fw, fr, br, og bw. Hvis du ikke forstår, hvad jeg mener, så spørg. Fra nu af vil jeg henvise til variablerne med de Navne, du gjorde for at gøre læsning lettere, efter alt fw står bare for FileWriter alligevel, så der bør ikke være for meget forvirring.

nøglen til dette spørgsmål er skjult inden for navnene på variablerne selv. Bemærk, hvordan de enten ender i Reader eller Writer Dette kan give os en subtil anelse om deres anvendelser. Det er klart, at FileWriter og BufferedWriter har at gøre med output på en eller anden måde. Ved at kigge over koden ser vi, at vores mistanker var rigtige, og at disse variabler på intet andet tidspunkt end inden for writeText(JTextArea area) – metoden vises. Så hvis variablen ikke bruges andre steder i koden, ville det være logisk at definere og initialisere dem inden for den metode, de bruges i, ikke kun gør det koden lettere at læse, fordi vi så “ved”, at disse variabler kun er relateret til den metode, men har også fordelen ved, at disse variabler fjernes i slutningen af metodeudførelsen og derved ikke efterlader variabler, der kun blev brugt meget kort. Ved disse regler kan vi sige, at det samme gælder for FileReader og BufferedReader.

se dette eksempel om variabelt omfang. (Se på de kommentarer, Jeg tilføjede til 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

fra dette eksempel bliver det mere klart, hvorfor variablerne defineres i metoderne snarere end som instansvariabler og initialiseres inden for konstruktøren. Det giver mulighed for meget renere kode samt at være mere readabe.

Hvorfor gør det hver gang metoden kaldes snarere end at bruge måske den samme instansvariabel?

nå dette spørgsmål har at gøre med variable typer. Vi kunne ikke genbruge en enkelt variabel til al information, da typerne ville have været forskellige.

hvis vi tager alle variablerne fra 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 ved vi, at vi ikke kan placere en værdi, der ikke er af samme type som variablen i den variabel, så noget som

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

fordi typerne simpelthen ikke stemmer overens.

giver mening?