Wat doet het 'nieuwe' sleutelwoord eigenlijk in Java, en moet ik het aanmaken van nieuwe objecten vermijden?

Ja, als u myMethod() 10 keer hebt aangeroepen, maakt het 10 unieke en afzonderlijke objecten aan.

het new sleutelwoord doet precies wat het zegt op het tin, het creëert een gloednieuw object, ongeacht of er al een bestaat. Het maakt een nieuw object en vult de verwijzing naar dat object in de variabele die het is gegeven, overschrijven elke eerdere waarde (object) de variabele gehouden.

wordt de variabele myObject telkens opnieuw toegewezen?

nogmaals, Ja, het zou opnieuw worden toegewezen met een nieuw object elke keer dat de methode werd aangeroepen. Een interessante opmerking hierover zou zijn dat de variabele niet “echt” opnieuw zou worden toegewezen als je de variabele definieert binnen het lichaam van de methode zelf, dus elke keer als de methode eindigt zal het de variabelen verwijderen die zijn gedefinieerd binnen de scope. Dus wat het eigenlijk doet is 10 individuele variabelen creëren en 10 individuele objecten toewijzen, hoewel zoals ik al zei de anderen automatisch verwijderd hadden moeten worden zodat het geen extra geheugen zou gebruiken.

in een notendop: moet ik zo ‘ n code alleen schrijven als ik van plan ben om die methode slechts één keer aan te roepen?

zoals ik al zei, in het voorbeeld hierboven zou elk object vernietigd worden aan het einde van de methode uitvoering (aangenomen dat je de object referentie niet toewijst aan een variabele buiten het bereik van de methode) dus in je voorbeeld zou je de methode graag zo vaak kunnen aanroepen als je wilde, maar elke keer zou op geen enkele manier verbonden zijn met de vorige aanroepen.

ik besef dat mijn manier van schrijven verwarrend kan zijn, dus als je wilt dat ik iets verduidelijk, vraag het dan gewoon.

‘ why not declare FileWriter, FileReader, BufferedReader and BufferedWriter at the top of the class as they did for the other variables?’

Oké, ik neem aan dat je begrijpt dat de variabelen niet echt worden genoemd FileWriter, FileReader, BufferedReader, en BufferedWriter, maar dit is het variabele type. Hun namen zijn fw, fr, br, en bw. Als je niet begrijpt wat ik bedoel, vraag het dan gewoon. Vanaf nu zal ik verwijzen naar de variabelen met de namen die je hebt gedaan om het lezen gemakkelijker te maken, tenslotte staat fw gewoon voor FileWriter dus er moet niet te veel verwarring zijn.

de sleutel tot deze vraag is verborgen in de namen van de variabelen zelf. Merk op hoe ze eindigen op Reader of Writer Dit kan ons een subtiele aanwijzing geven over hun gebruik. Het is duidelijk dat FileWriter en BufferedWriter op de een of andere manier met output te maken hebben. Door de code te bekijken zien we dat onze vermoedens juist waren en dat op geen enkel punt anders dan binnen de writeText(JTextArea area) methode deze variabelen verschijnen. Dus als de variabele niet ergens anders binnen de code wordt gebruikt zou het logisch zijn om ze te definiëren en te initialiseren binnen de methode waarin ze worden gebruikt, niet alleen maakt het de code gemakkelijker te lezen omdat we dan “weten” dat die variabelen alleen gerelateerd zijn aan die methode, maar heeft ook het voordeel dat die variabelen worden verwijderd aan het einde van de uitvoering van de methode, waardoor er geen variabelen bestaan die slechts heel kort werden gebruikt. Met deze regels kunnen we zeggen dat hetzelfde geldt voor FileReader en BufferedReader.

Bekijk dit voorbeeld over variabele scope. (Kijk naar de opmerkingen die ik heb toegevoegd aan de code)

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

uit dit voorbeeld wordt duidelijker waarom de variabelen in de methoden worden gedefinieerd in plaats van als instantievariabelen en geïnitialiseerd binnen de constructor. Het zorgt voor veel schonere code, evenals meer readabe.

waarom het elke keer doen als de methode wordt aangeroepen in plaats van misschien dezelfde instance variabele te gebruiken?

deze vraag heeft te maken met variabele types. We konden geen enkele variabele hergebruiken voor alle informatie, omdat de typen anders moesten zijn.

als we alle variabelen uit de 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

nemen, weten we nu dat we een waarde die niet van hetzelfde type is als de variabele niet in die variabele kunnen plaatsen, dus iets als

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

omdat de types gewoon niet overeenkomen.

zinvol?